# NaN, Infinity, True и None в JSON: что значит «Unexpected token ‘N’» и как исправить

> Исправить NaN в JSON, а с ним Infinity, undefined, True и None: почему JSON их не принимает, что пишут парсеры и как записать null.

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

JSON знает три слова: `true`, `false`, `null`. Строчными буквами, и на этом список кончается. `NaN`, `Infinity`, `undefined`, `True` и `None` — из других языков, и строгий парсер спотыкается на их первой букве.

## Значения Python и JavaScript, которых нет в JSON

Каждое значение ниже законно в каком-то языке и незаконно в JSON. `NaN` и `Infinity` приходят из арифметики с плавающей точкой, `True` и `None` — из печати словаря Python, `undefined` — из склейки строк в JavaScript:

```json
{"ratio": NaN, "limit": Infinity, "active": True, "parent": None, "note": undefined}
```

Для «значения нет» в JSON есть `null`, логические значения пишутся строчными `true` и `false`. У бесконечного или неопределённого числа записи в JSON нет: оно становится `null`, строкой или исчезает — смотря что ждёт читатель:

```json
{"ratio": null, "limit": "Infinity", "active": true, "parent": null}
```

## Почему в JSON нет NaN, Infinity и undefined (RFC 8259)

[RFC 8259, раздел 3](https://www.rfc-editor.org/rfc/rfc8259#section-3) перечисляет литералы `false`, `null` и `true`, требует писать их строчными и закрывает тему: «No other literal names are allowed», других литералов нет. [Раздел 6](https://www.rfc-editor.org/rfc/rfc8259#section-6) закрывает вторую дверь: «Numeric values that cannot be represented in the grammar below (such as Infinity and NaN) are not permitted» — числа, которые грамматика не описывает, вроде Infinity и NaN, запрещены.

Причина — переносимость. Число в JSON — это десятичный текст, который прочтёт любой язык; NaN и Infinity — особые состояния чисел с плавающей точкой, которые многие языки и базы данных хранить не умеют, а меток типов в JSON нет. `undefined` — собственное понятие JavaScript о «свойства нет вовсе»; в JSON это выражается отсутствием ключа.

## Ошибки NaN и True в разных парсерах

Ввод: `{"a":NaN}` и `{"a":True}`. Каждое сообщение получено запуском парсера 8 ноября 2026 года, у Firefox — по исходникам SpiderMonkey; в браузере перед ним стоит `JSON.parse:`, а после — строка и колонка. `Infinity`, `None` и `undefined` дают те же сообщения со своей первой буквой.

| Парсер | На NaN | На True |
| --- | --- | --- |
| Chrome 156, Node 24–25 (V8) | `Unexpected token 'N', "{"a":NaN}" is not valid JSON`. Перевод: «неожиданный токен N, это не валидный JSON» | `Unexpected token 'T', "{"a":True}" is not valid JSON`. Перевод: «неожиданный токен T, это не валидный JSON» |
| Firefox (SpiderMonkey) | `unexpected character`. Перевод: «неожиданный символ» | `unexpected character`. Перевод: «неожиданный символ» |
| Safari 27 (JavaScriptCore) | `JSON Parse error: Unexpected identifier "NaN"`. Перевод: «неожиданный идентификатор NaN» | `JSON Parse error: Unexpected identifier "True"`. Перевод: «неожиданный идентификатор True» |
| Python 3.9–3.14 | Принимает: `nan` | `Expecting value: line 1 column 6 (char 5)`. Перевод: «ожидалось значение: строка 1, колонка 6» |
| Go 1.25–1.27 | `invalid character 'N' looking for beginning of value`. Перевод: «недопустимый символ N там, где ожидалось начало значения» | `invalid character 'T' looking for beginning of value`. Перевод: «недопустимый символ T там, где ожидалось начало значения» |
| Java, Jackson 2.15–2.23 | Под таблицей | `Unrecognized token 'True': was expecting (JSON String, Number, Array, Object or token 'null', 'true' or 'false')`. Перевод: «нераспознанный токен True: ожидались строка, число, массив, объект или null, true, false» |
| C#, System.Text.Json 10 | `'N' is an invalid start of a value.`. Перевод: «N не может начинать значение» | `'T' is an invalid start of a value.`. Перевод: «T не может начинать значение» |
| C#, Newtonsoft.Json 13 | Принимает | `Unexpected character encountered while parsing value: T. Path 'a', line 1, position 5.`. Перевод: «при разборе значения встретился неожиданный символ T» |
| PHP 8.3 | `Syntax error`. Перевод: «синтаксическая ошибка» | `Syntax error`. Перевод: «синтаксическая ошибка» |
| Rust, serde_json 1.0 | `expected value at line 1 column 6`. Перевод: «ожидалось значение» | `expected value at line 1 column 6`. Перевод: «ожидалось значение» |
| jq 1.7.1 | Принимает и печатает `null` | `Invalid numeric literal at line 1, column 10`. Перевод: «неверный числовой литерал» |
| MySQL 8.4: столбец JSON | `Invalid JSON text: "Invalid value." at position 5`. Перевод: «неверный текст JSON: недопустимое значение» | `Invalid JSON text: "Invalid value." at position 5`. Перевод: «неверный текст JSON: недопустимое значение» |
| [Валидатор](https://jsonstatham.dev/ru/validator/) JSON Statham | Неверный литерал, строка 1, колонка 6 | Неверный литерал, строка 1, колонка 6 |

```text
Non-standard token 'NaN': enable `JsonReadFeature.ALLOW_NON_NUMERIC_NUMBERS` to allow
```

Если весь ввод — одно неверное слово, V8 обходится без токена и пишет `"NaN" is not valid JSON`; у этого семейства, включая `"[object Object]"`, [своя страница](https://jsonstatham.dev/ru/errors/undefined-is-not-valid-json/). Минус впереди меняет сообщение: на `-Infinity` V8 пишет `No number after minus sign in JSON at position 6 (line 1 column 7)`, Go — `invalid character 'I' in numeric literal`, Safari — `JSON Parse error: Invalid number`. Оборванный литерал вроде `tru` даёт у Go `invalid character '}' in literal true (expecting 'e')`, а у jq — `Invalid literal`.

Отдельно — о парсерах, которые принимают `NaN`: Python, Newtonsoft.Json и jq. Python принимает ещё `Infinity` и `-Infinity`, Newtonsoft — даже `undefined`. Цепочка, которая работает потому, что одна сторона снисходительна, ломается в тот день, когда на другой стороне окажется `JSON.parse`.

## Как заменить NaN и Infinity перед записью JSON

Исправлять там, где JSON пишется: превращать неконечные числа в `null` (или в строку, если читателю важно отличить NaN от «нет данных»). Каждый фрагмент запущен; в комментариях — настоящий вывод.

### JavaScript: JSON.stringify уже пишет null

```js
const row = { ratio: 0 / 0, limit: 1 / 0, note: undefined };

console.log(JSON.stringify(row)); // {"ratio":null,"limit":null}

const keepNames = (key, value) =>
  typeof value === 'number' && !Number.isFinite(value) ? String(value) : value;
console.log(JSON.stringify(row, keepNames)); // {"ratio":"NaN","limit":"Infinity"}
```

### Python: json.dumps пишет NaN, если не запретить

```python
import json
import math

def finite_or_none(value):
    if isinstance(value, float) and not math.isfinite(value):
        return None
    if isinstance(value, dict):
        return {k: finite_or_none(v) for k, v in value.items()}
    if isinstance(value, list):
        return [finite_or_none(v) for v in value]
    return value

row = {"ratio": float("nan"), "ok": True, "note": None}
print(json.dumps(row))  # {"ratio": NaN, "ok": true, "note": null}
print(json.dumps(finite_or_none(row), allow_nan=False))  # {"ratio": null, "ok": true, "note": null}
```

`allow_nan=False` превращает тихий `NaN` в `ValueError: Out of range float values are not JSON compliant` — как раз там, где ошибку и надо искать. А `print(row)` или `str(row)` — это синтаксис Python с `True` и `None`: отправлять нужно `json.dumps(row)`.

### Go: указатель, который пишется как null

```go
import "math"

type Row struct {
	Ratio *float64 `json:"ratio"`
}

func finite(f float64) *float64 {
	if math.IsNaN(f) || math.IsInf(f, 0) {
		return nil
	}
	return &f
}
```

Без него `json.Marshal` отказывается сразу: `json: unsupported value: NaN`.

### Java (Jackson)

```java
static Double finiteOrNull(double x) {
    return Double.isFinite(x) ? x : null;
}
```

По умолчанию Jackson пишет `NaN` строкой `"NaN"`: это валидный JSON, но строка там, где читатель ждёт число.

### C# (System.Text.Json)

```csharp
using System.Text.Json;

static double? FiniteOrNull(double x) => double.IsFinite(x) ? x : null;

Console.WriteLine(JsonSerializer.Serialize(new { ratio = FiniteOrNull(double.NaN) })); // {"ratio":null}
```

### PHP

```php
function finite_or_null(float $x): ?float
{
    return is_finite($x) ? $x : null;
}

echo json_encode(['ratio' => finite_or_null(NAN)], JSON_THROW_ON_ERROR); // {"ratio":null}
```

Без проверки `json_encode` падает с ошибкой 7, `Inf and NaN cannot be JSON encoded`.

## Как не пускать NaN, True и None в JSON

- **Сделать запись строгой.** `allow_nan=False` в Python; Go, C# и PHP отказываются и так. Громкая ошибка у источника лучше тихого `NaN`, на котором споткнётся только следующий сервис.
- **Решить, что значит «не число» для читателя:** `null`, если данных нет; строка вроде `"NaN"`, если различие важно; или вовсе без ключа.
- **Не печатать структуры данных в JSON.** `print`, `str()` и f-строки в Python, шаблонные строки и `String(value)` в JavaScript выдают исходный код, а не JSON.
- **Присматривать за снисходительными читателями.** Если данные принимают Python, Newtonsoft.Json или jq, их стоит один раз проверить строгим парсером.

## Проверить литералы в валидаторе

[Попробовать: открыть пример с неверным литералом в валидаторе](https://jsonstatham.dev/ru/validator/?sample=invalid_literal). Карточка цитирует слово целиком, `NaN` или `True`, и указывает на его первую букву; у `-Infinity` и `+NaN` — на знак. Голое слово на месте ключа — другая ошибка: [ключ без кавычек](https://jsonstatham.dev/ru/errors/unquoted-key/).

- [«undefined» is not valid JSON](https://jsonstatham.dev/ru/errors/undefined-is-not-valid-json/): когда весь ввод — `undefined` или `[object Object]`.
- [Неверное число](https://jsonstatham.dev/ru/errors/invalid-number/): `+1`, `.5`, `01` и другие числа, которые JSON пишет иначе.
- [Одинарные кавычки](https://jsonstatham.dev/ru/errors/single-quotes/): вторая половина напечатанного словаря Python.
- [Большие числа в JSON](https://jsonstatham.dev/ru/guides/json-big-numbers/): числа валидные, но теряющие точность.
- [Все ошибки JSON](https://jsonstatham.dev/ru/errors/)

## NaN, Infinity и None в JSON: частые вопросы

### Может ли в JSON быть NaN или Infinity?

Нет. RFC 8259 прямо запрещает числа вроде Infinity и NaN. Вместо них — `null`, строка или отсутствие ключа.

### Почему Python пишет NaN в JSON?

У `json.dumps` по умолчанию `allow_nan=True`, и он пишет `NaN`, `Infinity` и `-Infinity`. Python читает их обратно, а `JSON.parse` и Go — нет. С `allow_nan=False` вместо этого будет ошибка.

### True или None — это валидный JSON?

Нет. Литералы JSON пишутся строчными: `true`, `false`, `null`. `True` и `None` появляются, когда словарь Python печатают через `print()` или `str()`; нужен `json.dumps()`.

### Что JSON.stringify делает с undefined?

Свойства объекта со значением `undefined` выбрасывает, в массивах пишет вместо него `null`, а `JSON.stringify(undefined)` возвращает `undefined`, а не строку. `NaN` и `Infinity` становятся `null`.
