Глубокое копирование объекта в JavaScriptот JSON-трюка до structuredClone() и иммутабельных обновлений
Spread копирует только верхний уровень, а JSON-трюк теряет даты, undefined и циклы. Разбираем рекурсивный клон с WeakMap, встроенный structuredClone() и случаи, когда копия не нужна.
- Раздел
- JavaScript
- Стек
- JavaScriptstructuredCloneNode.js
- Уровень
- Средний
- Опубликовано
- Обновлено
- Чтение
- 8 мин
- Spread и Object.assign копируют только один уровень.
- JSON-трюк теряет Date, undefined, функции и падает на циклах.
- structuredClone() копирует данные, но не функции, DOM и прототипы.
- Иммутабельное обновление часто лучше полной копии.
- Проверьте, хватит ли поверхностной копии изменённой ветки
- Для данных используйте structuredClone()
- Для экземпляров классов добавьте свой метод clone()
- Циклы в своей функции отслеживайте через WeakMap
- Не мутируйте общее состояние, создавайте новое
Поверхностная копия и где она подводит#
В JavaScript объекты передаются по ссылке. Присваивание const b = a не копирует данные, а даёт второе имя тому же объекту. Первое, что пробуют для копирования, это spread или Object.assign. Оба создают новый объект, но только на один уровень: вложенные массивы и объекты остаются общими.
const user = { name: 'Анна', tags: ['admin'] };
const copy = { ...user }; // или Object.assign({}, user)
copy.name = 'Борис'; // оригинал не изменился
copy.tags.push('editor'); // а это изменило и user.tags
console.log(user.tags); // ['admin', 'editor']Такую ошибку трудно поймать: код с копией выглядит правильно, а данные меняются где-то в другом месте программы. Особенно часто это всплывает с настройками по умолчанию, состоянием формы и кешем ответов сервера. Нужна глубокая копия, которая проходит по всем уровням вложенности.
JSON.parse(JSON.stringify()): быстро и с потерями#
Классический приём из 2010-х: превратить объект в строку и разобрать обратно. Новый объект не связан с исходным ни на одном уровне. Для простых данных из JSON-ответа сервера этого хватает, и многие годами так и писали.
// 2013: самый короткий способ глубокого копирования
var settings = {
created: new Date(2013, 0, 15),
limit: undefined,
ratio: NaN,
format: function (v) { return v + '%'; },
nested: { a: 1, b: [1, 2, 3] }
};
var copy = JSON.parse(JSON.stringify(settings));
console.log(typeof copy.created); // "string", а не Date
console.log('limit' in copy); // false: ключ пропал
console.log(copy.ratio); // null
console.log(copy.format); // undefined: функции нетПроблема в том, что JSON знает только строки, числа, логические значения, null, массивы и простые объекты. Всё остальное по дороге искажается.
| Значение | Что получится после JSON |
|---|---|
Date | строка в формате ISO, методы даты потеряны |
undefined в объекте | ключ исчезает; в массиве превращается в null |
функции, Symbol | пропадают так же, как undefined |
NaN, Infinity | null |
Map, Set | пустой объект {} |
BigInt | исключение TypeError |
| циклическая ссылка | исключение TypeError |
| экземпляр класса | обычный объект без методов |
Есть и вопрос скорости: сериализация в строку и обратный разбор для большого дерева работают медленно и занимают память на промежуточную строку. Похожие ограничения сериализации знакомы по Flash: в заметке о SharedObject типы тоже приходилось восстанавливать вручную.
Рекурсивная функция с WeakMap#
Если нужна полная копия с датами, коллекциями и циклами, пишем рекурсивный обход. Ключевая деталь: WeakMap запоминает уже скопированные объекты. Когда обход снова встречает тот же объект, он возвращает готовую копию, а не уходит в бесконечную рекурсию. Заодно сохраняются общие ссылки: если два поля указывали на один объект, в копии они тоже будут указывать на одну копию.
function deepClone(value, seen = new WeakMap()) {
if (value === null || typeof value !== 'object') return value;
if (seen.has(value)) return seen.get(value);
if (value instanceof Date) return new Date(value.getTime());
if (value instanceof RegExp) return new RegExp(value.source, value.flags);
if (value instanceof Map) {
const out = new Map();
seen.set(value, out);
value.forEach((v, k) => out.set(deepClone(k, seen), deepClone(v, seen)));
return out;
}
if (value instanceof Set) {
const out = new Set();
seen.set(value, out);
value.forEach((v) => out.add(deepClone(v, seen)));
return out;
}
const out = Array.isArray(value)
? []
: Object.create(Object.getPrototypeOf(value));
seen.set(value, out);
for (const key of Reflect.ownKeys(value)) {
out[key] = deepClone(value[key], seen);
}
return out;
}
const a = { name: 'root' };
a.self = a; // циклическая ссылка
const b = deepClone(a);
console.log(b.self === b); // trueЧто эта версия делает и чего не делает:
- копирует
Date,RegExp,Map,Set, массивы и объекты, включая ключи-символы черезReflect.ownKeys; - сохраняет прототип через
Object.create, поэтому методы класса остаются доступны, но конструктор не вызывается и приватные поля#xне переносятся; - функции копирует по ссылке, и это обычно то, что нужно;
- не копирует геттеры и сеттеры как таковые: в копию попадёт текущее значение;
- не обрабатывает типизированные массивы и
ArrayBuffer; их можно добавить веткой сslice().
Рекурсия ограничена глубиной стека, но для обычных данных приложения это не проблема. А вот для очень глубоких деревьев лучше обход со своим стеком.
Что изменилось к 2026 году#
Главная новость: глубокое копирование встроено в платформу. Функция structuredClone() доступна глобально во всех актуальных браузерах, в Node.js с 17-й версии, в Deno и Bun. Она использует тот же алгоритм структурного клонирования, которым браузер передаёт данные в postMessage и сохраняет их в IndexedDB.
const state = {
updated: new Date(),
filters: new Set(['new', 'paid']),
cache: new Map([['page', 1]]),
};
state.parent = state;
const copy = structuredClone(state);
copy.updated instanceof Date; // true
copy.filters.has('paid'); // true
copy.parent === copy; // true: циклы сохраняются
class Point {
constructor(x, y) { this.x = x; this.y = y; }
length() { return Math.hypot(this.x, this.y); }
}
const p = structuredClone(new Point(3, 4));
p instanceof Point; // false: получился обычный объект
typeof p.length; // "undefined"
try {
structuredClone({ onClick() {} });
} catch (err) {
console.log(err.name); // "DataCloneError"
}structuredClone() корректно копирует даты, Map, Set, RegExp, ArrayBuffer и типизированные массивы, объекты ошибок, а также сохраняет циклы и общие ссылки. Но у неё есть свои границы, и их надо знать заранее:
- функции и объекты с методами в собственных свойствах вызывают
DataCloneError; - DOM-узлы тоже не клонируются; для них есть
node.cloneNode(true); - прототип теряется: экземпляр класса становится обычным объектом без методов;
- геттеры, сеттеры и дескрипторы не сохраняются, копируются только значения;
- свойства с ключами-символами пропускаются.
У функции есть второй аргумент с опцией transfer. Переданные в нём объекты, например ArrayBuffer, не копируются, а перемещаются в результат, и исходный буфер становится пустым. Это пригодится, когда большой бинарный массив нужно отдать другому коду без лишнего выделения памяти. Для обычных объектов приложения опция не нужна.
Практическое правило: для данных (состояние, ответ API, настройки) берите structuredClone(). Для объектов с поведением, то есть экземпляров классов, нужен собственный метод clone() в самом классе или рекурсивная функция из предыдущего раздела.
Иногда копия вообще не нужна#
Глубокое копирование часто лечит симптом: код мутирует общий объект, и копия нужна, чтобы мутация не задела соседей. Надёжнее не мутировать вовсе, а создавать новое значение только для изменённой ветки. Остальные ветки остаются общими, и это безопасно, пока их никто не меняет.
// вместо копирования и мутации: создаём новое значение
const next = {
...state,
filters: new Set([...state.filters, 'archived']),
};
const sorted = items.toSorted((a, b) => a.price - b.price);
const renamed = items.with(0, { ...items[0], title: 'Новое имя' });Методы toSorted(), toReversed(), toSpliced() и with() появились в ES2023 и возвращают новый массив, не трогая исходный. Object.freeze() поможет поймать случайную мутацию в режиме strict, но замораживает только верхний уровень. На этом же принципе построено состояние в React и Redux: сравнение по ссылке дёшево, а глубокая копия всего дерева на каждый чих дорога и ломает мемоизацию. Если вы обновляете список на Android, идея та же, что у DiffUtil в RecyclerView: новый список вместо изменения старого.
Как выбрать способ#
Прежде чем копировать, спросите себя, кто ещё держит ссылку на этот объект и собирается ли кто-то его менять. Если объект живёт внутри одной функции, копия не нужна. Если он приходит из общего хранилища, а вы хотите поправить поле для отображения, достаточно поверхностной копии нужной ветки. Полная глубокая копия оправдана, когда вы отдаёте данные в чужой код (плагин, обработчик, воркер) и не хотите, чтобы он повлиял на оригинал, или когда строите черновик формы, который пользователь может отменить. Учитывайте и стоимость: глубокое копирование большого дерева на каждое событие ввода заметно нагружает сборщик мусора.
- Нужно изменить одно поле: spread по пути к нему, без глубокой копии.
- Нужна независимая копия данных:
structuredClone(). - Данные пришли из JSON и обратно уйдут в JSON:
JSON.parse(JSON.stringify())допустим, но не обязателен. - Нужны экземпляры классов с методами: метод
clone()или рекурсия сWeakMap. - Нужна копия DOM-фрагмента:
cloneNode(true), а не объектные функции.
Ссылочная природа объектов важна и в интерфейсе: когда один обработчик обслуживает весь список, данные строки надёжнее читать из data-атрибутов, чем держать общий изменяемый объект, как в заметке про делегирование событий. Другие практические разборы ищите в разделе JavaScript.
«Копируйте данные, а не поведение: structuredClone() честно отказывается клонировать функции.»
Главный вывод заметки


