ENRU

Неверный escape в JSON: что значит «Bad escaped character» и как исправить

Обновлено

Обратный слэш обещает escape-последовательность. \U обещание не выполняет. Внутри строки JSON после обратного слэша может стоять ровно одно из девяти, а путь Windows или регулярное выражение обычно приносят что-то другое.

Путь Windows, который ломает JSON

Самый частый случай: путь вставлен в строку как есть. \U и \d — не escape-последовательности JSON, и парсер останавливается на первой:

{"path":"C:\Users\dev"}

Нужно удвоить каждый обратный слэш или взять прямые слэши, которые Windows в путях тоже понимает. Обе строки ниже валидны:

{"path":"C:\\Users\\dev"}
{"path":"C:/Users/dev"}

Хуже ошибки только путь, который не падает. "C:\temp\new" — валидный JSON: \t — это таб, \n — перевод строки, и после разбора получается девять символов без единого обратного слэша. Регулярные выражения в конфигах упираются в ту же стену: "\d+" — ошибка, а задуманный шаблон — "\\d+".

Какие escape-последовательности разрешает JSON (RFC 8259)

RFC 8259, раздел 7 перечисляет все escape-последовательности, какие есть. После обратного слэша идёт один из восьми символов или u и ровно четыре шестнадцатеричные цифры:

\"  кавычка             \\  обратный слэш   \/  слэш
\b  забой (backspace)   \f  прогон страницы  \n  перевод строки
\r  возврат каретки     \t  таб              \uXXXX  любая кодовая единица UTF-16

Нет ни \', ни \x41, ни \0, ни \a с \v, ни длинной формы вроде \U0001F600. Символ за пределами базовой плоскости Unicode пишется суррогатной парой UTF-16: U+1F600 — это \uD83D\uDE00. \u1F600 — не ошибка, а сюрприз: \u берёт ровно четыре цифры, так что это U+1F60 и следом 0.

Ошибка неверного escape в разных парсерах

Два ввода: путь выше и {"s":"\u12G4"}, где G — не шестнадцатеричная цифра. Каждое сообщение получено запуском парсера 8 ноября 2026 года, у Firefox — по исходникам SpiderMonkey. Go 1.27 берёт последовательность в обратные кавычки, поэтому два его сообщения — под таблицей, как напечатаны.

ПарсерНа C:\UsersНа \u12G4
Chrome 156, Node 24–25 (V8)Bad escaped character in JSON at position 12 (line 1 column 13). Перевод: «недопустимый экранированный символ, позиция 12»Bad Unicode escape in JSON at position 10 (line 1 column 11). Перевод: «неверная escape-последовательность Unicode, позиция 10»
Firefox (SpiderMonkey)bad escaped character. Перевод: «недопустимый экранированный символ»bad Unicode escape. Перевод: «неверный escape Unicode»
Safari 27 (JavaScriptCore)JSON Parse error: Invalid escape character U. Перевод: «недопустимый escape-символ U»JSON Parse error: "\u12G4" is not a valid unicode escape. Перевод: «\u12G4 — неверный escape Unicode»
Python 3.9–3.14Invalid \escape: line 1 column 12 (char 11). Перевод: «неверный \escape: строка 1, колонка 12»Invalid \uXXXX escape: line 1 column 8 (char 7). Перевод: «неверный escape \uXXXX»
Go 1.25–1.26invalid character 'U' in string escape code. Перевод: «недопустимый символ U в escape-коде строки»invalid character 'G' in \u hexadecimal character escape. Перевод: «недопустимый символ G в шестнадцатеричном escape \u»
Go 1.27Под таблицейПод таблицей
Java, Jackson 2.15–2.23Unrecognized character escape 'U' (code 85). Перевод: «нераспознанный escape символа U»Unexpected character ('G' (code 71)): expected a hex-digit for character escape sequence. Перевод: «неожиданный символ G: ожидалась шестнадцатеричная цифра»
C#, System.Text.Json 10'U' is an invalid escapable character within a JSON string. The string should be correctly escaped.. Перевод: «U нельзя экранировать в строке JSON»'G' is not a hex digit following '\u' within a JSON string. The string should be correctly escaped.. Перевод: «G после \u — не шестнадцатеричная цифра»
C#, Newtonsoft.Json 13Bad JSON escape sequence: \U. Path 'path', line 1, position 13.. Перевод: «неверная escape-последовательность JSON: \U»Invalid Unicode escape sequence: \u12G4. Path 's', line 1, position 8.. Перевод: «неверная escape-последовательность Unicode»
PHP 8.3Syntax error. Перевод: «синтаксическая ошибка»Syntax error. Перевод: «синтаксическая ошибка»
Rust, serde_json 1.0invalid escape at line 1 column 13. Перевод: «неверный escape»invalid escape at line 1 column 12. Перевод: «неверный escape»
jq 1.7.1Invalid escape at line 1, column 22. Перевод: «неверный escape»Invalid characters in \uXXXX escape at line 1, column 13. Перевод: «недопустимые символы в escape \uXXXX»
MySQL 8.4: столбец JSONInvalid JSON text: "Invalid escape character in string." at position 11. Перевод: «недопустимый escape-символ в строке»Invalid JSON text: "Incorrect hex digit after \u escape in string." at position 6. Перевод: «неверная шестнадцатеричная цифра после \u»
Валидатор JSON StathamНеверный escape, строка 1, колонка 13Неверный escape, строка 1, колонка 11: «неполный \u-escape»
invalid escape sequence `\U` in string
invalid escape sequence `\u12G4` in string

Python указывает на обратный слэш, V8 и наш валидатор — на символ после него. Некоторые парсеры можно научить принимать любой escape, и это хуже ошибки: с JsonReadFeature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER Jackson читает C:\Users как C:Users, молча теряя слэш. Newtonsoft.Json по умолчанию принимает \'.

Как экранировать обратный слэш в JSON

Не удваивать слэши руками: отдать сырую строку сериализатору, и он сам напишет \\. Каждый фрагмент ниже запущен и печатает {"path":"C:\\Users\\dev"} (Python добавляет пробел после двоеточия).

JavaScript

const path = String.raw`C:\Users\dev`;
const json = JSON.stringify({ path });

console.log(json); // {"path":"C:\\Users\\dev"}
console.log(JSON.parse(json).path === path); // true

Python: два слоя экранирования

import json

path = r"C:\Users\dev"
print(json.dumps({"path": path}))  # {"path": "C:\\Users\\dev"}

data = json.loads(r'{"path": "C:\\Users\\dev"}')
print(data["path"] == path)  # True

Без приставки r Python сам превращает \\ в \ ещё до того, как текст увидит JSON, и json.loads останавливается на Invalid \escape. Та же двойная обработка есть в строковых литералах JavaScript, поэтому в примере для JavaScript стоит String.raw.

Go

import "encoding/json"

func pathJSON() ([]byte, error) {
	return json.Marshal(map[string]string{"path": `C:\Users\dev`})
}

Java (Jackson)

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;

static String pathJson(ObjectMapper mapper) throws JsonProcessingException {
    return mapper.writeValueAsString(Map.of("path", "C:\\Users\\dev"));
}

C# (System.Text.Json)

using System.Text.Json;

var json = JsonSerializer.Serialize(new { path = @"C:\Users\dev" });
Console.WriteLine(json); // {"path":"C:\\Users\\dev"}

PHP

$json = json_encode(['path' => 'C:\Users\dev'], JSON_THROW_ON_ERROR);
echo $json; // {"path":"C:\\Users\\dev"}

Как больше не ловить неверный escape

  • Сериализовать, а не набирать. Любой сериализатор правильно экранирует слэши и кавычки; \U берётся из JSON, написанного руками в коде.
  • Хранить пути с прямыми слэшами. C:/Users/dev не нужно экранировать вовсе, и API Windows такой путь понимают.
  • Удваивать слэши в регулярных выражениях. Конфиг JSON с шаблоном хранит "\\d+", "\\s", "\\.".
  • Искать однобуквенные escape в путях. Путь, который разбирается без ошибки, но содержит таб или перевод строки, как C:\temp\new, потерял свои слэши.

Проверить escape-последовательности в валидаторе

Попробовать: открыть пример с неверным escape в валидаторе. Карточка называет последовательность (для пути — \U) и перечисляет девять допустимых. Для короткого или сломанного \u она указывает на первый символ, который не шестнадцатеричная цифра. Голый перевод строки сразу после обратного слэша считается управляющим символом.

Escape-последовательности в JSON: частые вопросы

Какие escape-последовательности допустимы в JSON?

\", \\, \/, \b, \f, \n, \r, \t и \u с ровно четырьмя шестнадцатеричными цифрами. И больше никаких: ни \', ни \x41, ни \0, ни \U0001F600.

Как записать путь Windows в JSON?

Удвоить каждый обратный слэш, "C:\\Users\\dev", или взять прямые слэши, "C:/Users/dev". Сериализатор удвоит слэши сам.

Как записать эмодзи в строку JSON через \u?

Суррогатной парой: U+1F600 — это \uD83D\uDE00. Или просто самим символом: JSON — это UTF-8. \u1F600 читается как U+1F60 и следом 0.

Правда ли \/ допустимая escape-последовательность?

Да. Экранировать прямой слэш можно, это ничего не меняет. json_encode в PHP делает так по умолчанию, поэтому https:\/\/ в его выводе — норма.