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

> Исправить invalid escape в JSON: пути Windows, обратные слэши в регулярках и неполный \u, точные сообщения парсеров и как экранировать верно.

- Адрес: https://jsonstatham.dev/ru/errors/invalid-escape/
- Язык: Русский (ru)
- Английская версия: https://jsonstatham.dev/errors/invalid-escape.md
- Обновлено: 2026-11-08

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

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

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

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

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

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

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

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

[RFC 8259, раздел 7](https://www.rfc-editor.org/rfc/rfc8259#section-7) перечисляет все escape-последовательности, какие есть. После обратного слэша идёт один из восьми символов или `u` и ровно четыре шестнадцатеричные цифры:

```text
\"  кавычка             \\  обратный слэш   \/  слэш
\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.14 | `Invalid \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.26 | `invalid 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.23 | `Unrecognized 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 13 | `Bad 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.3 | `Syntax error`. Перевод: «синтаксическая ошибка» | `Syntax error`. Перевод: «синтаксическая ошибка» |
| Rust, serde_json 1.0 | `invalid escape at line 1 column 13`. Перевод: «неверный escape» | `invalid escape at line 1 column 12`. Перевод: «неверный escape» |
| jq 1.7.1 | `Invalid escape at line 1, column 22`. Перевод: «неверный escape» | `Invalid characters in \uXXXX escape at line 1, column 13`. Перевод: «недопустимые символы в escape \uXXXX» |
| MySQL 8.4: столбец JSON | `Invalid 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» |
| [Валидатор](https://jsonstatham.dev/ru/validator/) JSON Statham | Неверный escape, строка 1, колонка 13 | Неверный escape, строка 1, колонка 11: «неполный \u-escape» |

```text
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

```js
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: два слоя экранирования

```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

```go
import "encoding/json"

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

### Java (Jackson)

```java
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)

```csharp
using System.Text.Json;

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

### PHP

```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 в валидаторе](https://jsonstatham.dev/ru/validator/?sample=invalid_escape). Карточка называет последовательность (для пути — `\U`) и перечисляет девять допустимых. Для короткого или сломанного `\u` она указывает на первый символ, который не шестнадцатеричная цифра. Голый перевод строки сразу после обратного слэша считается [управляющим символом](https://jsonstatham.dev/ru/errors/control-character/).

- [Управляющий символ в строке](https://jsonstatham.dev/ru/errors/control-character/): голый таб или перевод строки там, где нужны `\t` или `\n`.
- [Незакрытая строка](https://jsonstatham.dev/ru/errors/unclosed-string/): путь, который кончается обратным слэшем, `"C:\temp\"`, экранирует собственную закрывающую кавычку.
- [Одинарные кавычки](https://jsonstatham.dev/ru/errors/single-quotes/): `\'` не существует, потому что строки JSON никогда не берутся в одинарные кавычки.
- [Все ошибки JSON](https://jsonstatham.dev/ru/errors/)

## 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:\/\/` в его выводе — норма.
