JSON: обмен данными

Внутри программы данные живут объектами и массивами. Но стоит отправить их по сети или сохранить в файл — и структура исчезает: наружу уходят только байты, то есть текст. JSON — договор о том, как записать структуру текстом, чтобы на другом конце её собрали обратно точно такой же.

Синтаксис JSON вырос из объектов JavaScript, но сам формат давно ничей: его читают Python, Go, PHP, PostgreSQL и любой HTTP-клиент. Победил он скукой — шесть типов значений (объект, массив, строка, число, true/false, null) и никаких схем, тегов и атрибутов, как в XML. Правила при этом жёсткие: ключи и строки только в двойных кавычках, комментариев нет, висячая запятая запрещена.

const user = { name: "Ада", age: 36 };
const text = JSON.stringify(user);

console.log(typeof text);
console.log(text);

JSON.stringify берёт значение и возвращает строку. Вглубь он спускается сам: вложенные объекты и массивы обрабатываются рекурсивно, склеивать текст вручную не нужно.

const cart = { items: ["чай", "мёд"], total: 540, paid: false };

console.log(JSON.stringify(cart));
console.log(JSON.stringify([1, "два", null]));

Заметьте: в результате нет ни одного лишнего пробела, а ключи стоят в кавычках, хотя в исходном объекте кавычек не было. Это не вопрос стиля — так требует формат.

const node = { name: "корень" };
node.self = node;

try {
  JSON.stringify(node);
} catch (error) {
  console.log(error.name);
}

JSON.parse делает обратное: читает строку и строит из неё значение. Обратные кавычки в примере — просто способ написать строку с двойными кавычками внутри, к JSON они отношения не имеют.

const text = `{"city": "Дубай", "temp": 41}`;
const data = JSON.parse(text);

console.log(data.temp);
console.log(Array.isArray(JSON.parse(`[10, 20]`)));

Слово «строит» здесь важное: получается совершенно новое значение, никак не связанное с исходным объектом. На этом держится старый трюк глубокого копирования — объект прогоняют в текст и обратно.

const a = { tags: ["js"], meta: { ok: true } };
const b = JSON.parse(JSON.stringify(a));

b.meta.ok = false;
console.log(a.meta.ok);

Копия через JSON — трюк на скорую руку. Для честной копии сегодня есть structuredClone: он умеет Date, Map и Set.

JSON знает только свои шесть типов, поэтому всё остальное он либо выбрасывает, либо превращает во что-то похожее — молча, без предупреждений.

const log = { at: new Date("2024-01-01T00:00:00Z"), note: undefined, hi: () => 1 };

console.log(JSON.stringify(log));
console.log(JSON.stringify([undefined, NaN]));

Отдельная ловушка — даты. Date уезжает читаемой ISO-строкой, но обратно строка датой не становится: разбор вернёт именно строку, и getFullYear у неё уже не спросишь.

const text = JSON.stringify({ at: new Date("2024-01-01T00:00:00Z") });
const back = JSON.parse(text);

console.log(typeof back.at);
console.log(back.at instanceof Date);

Третий аргумент JSON.stringify — отступ. Число означает столько пробелов на уровень, строка (например "\t") — свой символ отступа. Второй аргумент при этом обычно не нужен, поэтому на его месте ставят null.

const user = { name: "Ада", lang: "js" };

console.log(JSON.stringify(user, null, 2));

Второй аргумент — replacer, фильтр. Массив строк оставит только перечисленные ключи; функция вызывается для каждой пары и решает, что записать. Удобно, когда в объекте есть то, чему не место в логах.

const account = { login: "ada", password: "1234", city: "Лондон" };

console.log(JSON.stringify(account, ["login", "city"]));

const text = `{"title": "релиз", "at": "2024-01-01T00:00:00.000Z"}`;
const data = JSON.parse(text, (key, value) =>
  key === "at" ? new Date(value) : value
);

console.log(data.at.getUTCFullYear());

Строка, пришедшая извне, — это не обещание корректного JSON. Пустой ответ, HTML страницы ошибки вместо данных, лишняя запятая — и JSON.parse бросает SyntaxError, а без обработки падает весь код вокруг. Перехватить такую ошибку помогает конструкция try...catch: код, который может сломаться, кладут в блок try, и если там брошена ошибка, выполнение не обрывается, а переходит в блок catch. Туда же приходит объект ошибки, и по его полю name видно, что случилось. Подробно конструкцию разбирает статья «try..catch: перехват ошибок».

const bad = `{"name": "Ада",}`;

try {
  JSON.parse(bad);
} catch (error) {
  console.log(error.name);
}

Поэтому чужой текст разбирают в try...catch. Чтобы не повторять одно и то же в каждом месте, заводят маленькую обёртку с запасным значением. Объект ошибки ей не нужен, поэтому скобки после catch опущены — так тоже можно.

function safeParse(text, fallback) {
  try {
    return JSON.parse(text);
  } catch {
    return fallback;
  }
}

console.log(safeParse(`{"ok": true}`, null).ok);
console.log(safeParse("не json", null));