ENRU

Слишком глубокая вложенность JSON: что значит «Maximum stack depth exceeded» и как исправить

Обновлено

Пятьсот двенадцать уровней скобок — это много. Глубже обычно не данные, а ошибка генератора. Предел глубины есть у каждого парсера, записан он где-нибудь или нет, и документ глубже предела падает, каким бы валидным он ни был.

Как выглядит слишком глубокий JSON и плоская версия

JSON, написанный руками, редко уходит глубже десяти уровней. Документы, которые упираются в предел, растут сами: ответ внутри ответа внутри ответа, дерево с циклом, сериализованное как есть, конверт вокруг данных на каждой повторной попытке. Такая форма добавляет уровень на каждую запись:

{"id": 1, "reply": {"id": 2, "reply": {"id": 3, "reply": {"id": 4, "reply": null}}}}

Тысяча ответов — тысяча уровней. Те же данные плоским списком с идентификатором родителя остаются в двух уровнях, какой бы длинной ни была ветка:

[{"id": 1, "parent": null}, {"id": 2, "parent": 1}, {"id": 3, "parent": 2}, {"id": 4, "parent": 3}]

Почему парсеры ограничивают вложенность (RFC 8259)

В грамматике предела нет: [[[[1]]]] валиден на любой глубине. RFC 8259, раздел 9 оставляет это парсеру: «An implementation may set limits on the maximum depth of nesting» — реализация вправе ограничить глубину вложенности. Поэтому каждый парсер выбирает свой предел, и числа ниже различаются в сотню раз.

Причина ограничения — стек вызовов. Многие парсеры обрабатывают массив, вызывая сами себя для каждого элемента, и каждый уровень стоит кадра стека; мегабайт символов [ — это миллион уровней. Без предела это падение процесса и простой способ положить любой эндпоинт, который разбирает присланное.

Пределы вложенности JSON в разных парсерах

Измерено 8 ноября 2026 года разбором вложенных массивов растущей глубины, [[…]]. «Уровни» считаются скобками: [[1]] — два уровня.

ПарсерПредел по умолчаниюСообщение за пределом
Chrome 156, Node 24–25 (V8)Не достигнут: разобрано 1 000 000 уровнейОшибки нет
Safari 27 (JavaScriptCore)Не достигнут: разобрано 100 000 уровнейОшибки нет
Python 3.9994 уровня (предел рекурсии 1000)RecursionError: maximum recursion depth exceeded while decoding a JSON array from a unicode string. Перевод: «превышена глубина рекурсии при разборе массива JSON»
Python 3.14Задаёт стек C: 6334 уровня в Alpine LinuxRecursionError: Stack overflow (used 992 kB) while decoding a JSON array from a unicode string. Перевод: «переполнение стека при разборе массива JSON»
Go 1.25–1.2610 000invalid character '[' exceeded max depth. Перевод: «символ [ превысил максимальную глубину»
Go 1.2710 000exceeded max depth. Перевод: «превышена максимальная глубина»
Java, Jackson 2.151000Depth (1001) exceeds the maximum allowed nesting depth (1000). Перевод: «глубина 1001 больше допустимой вложенности 1000»
Java, Jackson 2.231000Под таблицей
C#, System.Text.Json 1064The maximum configured depth of 64 has been exceeded. Cannot read next JSON array.. Перевод: «превышена заданная максимальная глубина 64, следующий массив не прочитать»
C#, Newtonsoft.Json 1364Начинается с «The reader» и называет MaxDepth of 64
PHP 8.3depth 512, при котором проходит 511 вложенных массивовMaximum stack depth exceeded. Перевод: «превышена максимальная глубина стека» (код ошибки 1)
Rust, serde_json 1.0128 вложенных массивов уже не проходятrecursion limit exceeded at line 1 column 128. Перевод: «превышен предел рекурсии»
jq 1.7.1256Exceeds depth limit for parsing at line 1, column 257. Перевод: «превышен предел глубины разбора»
MySQL 8.4100The JSON document exceeds the maximum depth.. Перевод: «документ JSON глубже допустимого»
JSON Statham512Слишком глубокая вложенность, на 513-й открывающей скобке
Document nesting depth (1001) exceeds the maximum allowed (1000, from `StreamReadConstraints.getMaxNestingDepth()`)

Настоящая проблема — разброс. Документ в 100 уровней проходит Go, Jackson, PHP и Python и падает в C# с умолчанием 64; MySQL отвергает 101. Сервис, который принимает всё, что может разобрать, может выдать то, что сосед не прочтёт.

Как измерить глубину и задать предел

Сначала узнать, насколько документ глубок. Функции на JavaScript и Python ниже считают скобки вне строк и работают даже на тексте, который парсер отвергает; Go считает токены через json.Decoder. Поднимать предел стоит, только если глубина настоящая, а ввод доверенный. Все фрагменты запущены на 512 и 513 уровнях.

JavaScript: глубина текста JSON

function maxDepth(text) {
  let depth = 0;
  let deepest = 0;
  let inString = false;
  for (let i = 0; i < text.length; i++) {
    const c = text[i];
    if (inString) {
      if (c === '\\') i++;
      else if (c === '"') inString = false;
    } else if (c === '"') inString = true;
    else if (c === '{' || c === '[') deepest = Math.max(deepest, ++depth);
    else if (c === '}' || c === ']') depth--;
  }
  return deepest;
}

Python

def max_depth(text):
    depth = deepest = 0
    in_string = escaped = False
    for c in text:
        if in_string:
            if escaped:
                escaped = False
            elif c == "\\":
                escaped = True
            elif c == '"':
                in_string = False
        elif c == '"':
            in_string = True
        elif c in "[{":
            depth += 1
            deepest = max(deepest, depth)
        elif c in "]}":
            depth -= 1
    return deepest

Настройки глубины в Python нет. В 3.9 более высокий sys.setrecursionlimit позволяет json.loads уйти глубже; в 3.14 предел задаёт стек C, и настройка за него не пускает. Сделать данные плоскими — способ, который работает везде.

Go

import (
	"encoding/json"
	"errors"
	"io"
	"strings"
)

func maxDepth(input string) (int, error) {
	dec := json.NewDecoder(strings.NewReader(input))
	depth, deepest := 0, 0
	for {
		tok, err := dec.Token()
		if errors.Is(err, io.EOF) {
			return deepest, nil
		}
		if err != nil {
			return deepest, err
		}
		switch tok {
		case json.Delim('{'), json.Delim('['):
			depth++
			deepest = max(deepest, depth)
		case json.Delim('}'), json.Delim(']'):
			depth--
		}
	}
}

Предел 10 000 в encoding/json не настраивается; Go 1.27 применяет его и к Decoder.Token, поэтому на более глубоком документе функция вернёт 10 000 и ошибку.

Java (Jackson): задать предел явно

import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.StreamReadConstraints;
import com.fasterxml.jackson.databind.ObjectMapper;

static ObjectMapper mapperWithDepth(int maxDepth) {
    JsonFactory factory = JsonFactory.builder()
        .streamReadConstraints(StreamReadConstraints.builder().maxNestingDepth(maxDepth).build())
        .build();
    return new ObjectMapper(factory);
}

C# (System.Text.Json)

using System.Text.Json;

static JsonDocument ParseDeep(string text) =>
    JsonDocument.Parse(text, new JsonDocumentOptions { MaxDepth = 512 });

Тот же MaxDepth есть у JsonSerializerOptions и JsonReaderOptions; значение по умолчанию, 0, означает 64 (описание MaxDepth).

PHP

$data = json_decode($text, true, 513, JSON_THROW_ON_ERROR);

PHP считает на один уровень больше, чем скобок: depth 512 отвергает 512 вложенных массивов, а принимает их 513.

Как держать JSON неглубоким

  • Хранить деревья плоско. Список узлов с parent или путь у каждого узла держат глубину постоянной, как бы ни росло дерево.
  • Искать циклы. Прямой цикл сериализаторы не пишут (Converting circular structure to JSON, ValueError: Circular reference detected, json: unsupported value: encountered a cycle), но самописный обход и копирование с ограничением глубины выдают документ ровно той глубины, что их предел.
  • Оборачивать один раз. Промежуточный слой, который добавляет конверт на каждой повторной попытке или каждом переходе, делает плоские данные глубокими; сначала снять старый конверт, потом надевать новый.
  • Договориться о пределе по всей цепочке. Решает самый строгий читатель: если один из потребителей на умолчаниях C#, настоящий предел всей цепочки — 64.

Проверить глубину в валидаторе

Попробовать: открыть пример со слишком глубокой вложенностью в валидаторе. JSON Statham принимает 512 уровней объектов и массивов вместе и сообщает о 513-й открывающей скобке с её строкой и колонкой. Для валидного документа валидатор показывает глубину в статистике, так что видно, далеко ли до чужого предела.

Глубина вложенности JSON: частые вопросы

Какая максимальная глубина вложенности у JSON?

Стандарт её не задаёт: RFC 8259 оставляет выбор парсеру. Умолчания: 64 в C#, 100 в MySQL, 256 в jq 1.7, 512 в PHP и JSON Statham, 1000 в Jackson, 10 000 в Go; у V8 фиксированного предела нет.

Как поднять предел глубины?

C#: MaxDepth в настройках. Jackson: StreamReadConstraints с maxNestingDepth. PHP: третий аргумент json_decode. Предел Go в 10 000 не меняется, у Python он следует за стеком. Поднимать стоит только для доверенного ввода.

Что значит «Maximum stack depth exceeded» в PHP?

json_decode вышел за свой аргумент depth, по умолчанию 512. PHP считает на один уровень больше, чем скобок, поэтому 512 вложенным массивам нужен depth 513. Код ошибки — 1.

Какую глубину JSON принимает JSON Statham?

512 уровней объектов и массивов вместе. 513-я открывающая скобка получает «Слишком глубокая вложенность» с номером строки и колонки.