Глубокое копирование объекта в JavaScript

Глубокое копирование объекта в JavaScriptот JSON-трюка до structuredClone() и иммутабельных обновлений

Spread копирует только верхний уровень, а JSON-трюк теряет даты, undefined и циклы. Разбираем рекурсивный клон с WeakMap, встроенный structuredClone() и случаи, когда копия не нужна.

Раздел
JavaScript
Стек
JavaScriptstructuredCloneNode.js
Уровень
Средний
Опубликовано
Обновлено
Чтение
8 мин
Коротко
  • Spread и Object.assign копируют только один уровень.
  • JSON-трюк теряет Date, undefined, функции и падает на циклах.
  • structuredClone() копирует данные, но не функции, DOM и прототипы.
  • Иммутабельное обновление часто лучше полной копии.
Как решаем
  1. Проверьте, хватит ли поверхностной копии изменённой ветки
  2. Для данных используйте structuredClone()
  3. Для экземпляров классов добавьте свой метод clone()
  4. Циклы в своей функции отслеживайте через WeakMap
  5. Не мутируйте общее состояние, создавайте новое

Поверхностная копия и где она подводит#

В JavaScript объекты передаются по ссылке. Присваивание const b = a не копирует данные, а даёт второе имя тому же объекту. Первое, что пробуют для копирования, это spread или Object.assign. Оба создают новый объект, но только на один уровень: вложенные массивы и объекты остаются общими.

JavaScript
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-ответа сервера этого хватает, и многие годами так и писали.

JavaScript
// 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, Infinitynull
Map, Setпустой объект {}
BigIntисключение TypeError
циклическая ссылкаисключение TypeError
экземпляр классаобычный объект без методов

Есть и вопрос скорости: сериализация в строку и обратный разбор для большого дерева работают медленно и занимают память на промежуточную строку. Похожие ограничения сериализации знакомы по Flash: в заметке о SharedObject типы тоже приходилось восстанавливать вручную.

Рекурсивная функция с WeakMap#

Если нужна полная копия с датами, коллекциями и циклами, пишем рекурсивный обход. Ключевая деталь: WeakMap запоминает уже скопированные объекты. Когда обход снова встречает тот же объект, он возвращает готовую копию, а не уходит в бесконечную рекурсию. Заодно сохраняются общие ссылки: если два поля указывали на один объект, в копии они тоже будут указывать на одну копию.

JavaScript
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.

JavaScript
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() в самом классе или рекурсивная функция из предыдущего раздела.

Иногда копия вообще не нужна#

Глубокое копирование часто лечит симптом: код мутирует общий объект, и копия нужна, чтобы мутация не задела соседей. Надёжнее не мутировать вовсе, а создавать новое значение только для изменённой ветки. Остальные ветки остаются общими, и это безопасно, пока их никто не меняет.

JavaScript
// вместо копирования и мутации: создаём новое значение
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: новый список вместо изменения старого.

Как выбрать способ#

Прежде чем копировать, спросите себя, кто ещё держит ссылку на этот объект и собирается ли кто-то его менять. Если объект живёт внутри одной функции, копия не нужна. Если он приходит из общего хранилища, а вы хотите поправить поле для отображения, достаточно поверхностной копии нужной ветки. Полная глубокая копия оправдана, когда вы отдаёте данные в чужой код (плагин, обработчик, воркер) и не хотите, чтобы он повлиял на оригинал, или когда строите черновик формы, который пользователь может отменить. Учитывайте и стоимость: глубокое копирование большого дерева на каждое событие ввода заметно нагружает сборщик мусора.

  1. Нужно изменить одно поле: spread по пути к нему, без глубокой копии.
  2. Нужна независимая копия данных: structuredClone().
  3. Данные пришли из JSON и обратно уйдут в JSON: JSON.parse(JSON.stringify()) допустим, но не обязателен.
  4. Нужны экземпляры классов с методами: метод clone() или рекурсия с WeakMap.
  5. Нужна копия DOM-фрагмента: cloneNode(true), а не объектные функции.

Ссылочная природа объектов важна и в интерфейсе: когда один обработчик обслуживает весь список, данные строки надёжнее читать из data-атрибутов, чем держать общий изменяемый объект, как в заметке про делегирование событий. Другие практические разборы ищите в разделе JavaScript.

Node.js 17structuredClone() в глобальной области
ES2023toSorted() и with() без мутации
DataCloneErrorошибка при клонировании функции

«Копируйте данные, а не поведение: structuredClone() честно отказывается клонировать функции.»

Главный вывод заметки

Вопросы и ответы

Вопросы и ответы

Чем structuredClone() лучше JSON.parse(JSON.stringify())?
Она сохраняет Date, Map, Set, RegExp, типизированные массивы, значения undefined и NaN, а также циклические и общие ссылки. JSON превращает дату в строку, теряет undefined и падает на циклах. Ограничения у structuredClone тоже есть: функции, DOM-узлы и прототипы классов.
Почему после structuredClone() у объекта пропали методы?
Алгоритм структурного клонирования не переносит прототип: экземпляр класса превращается в обычный объект с теми же полями данных. Чтобы получить полноценный экземпляр, добавьте в класс метод clone(), который вызывает конструктор, или создайте новый объект через new и скопируйте поля.
Можно ли клонировать объект с функцией внутри?
structuredClone() бросит DataCloneError. Варианты: вынести функции из данных, написать свою рекурсивную функцию, которая копирует функции по ссылке, или использовать готовую утилиту вроде cloneDeep из lodash, которая обходит такие значения по своим правилам.
Как скопировать объект в старом браузере без structuredClone?
Для чистых данных подойдёт JSON-трюк, если в объекте нет дат, undefined и циклов. Для всего остального используйте рекурсивную функцию с WeakMap из этой заметки или полифил из core-js, который реализует structuredClone поверх возможностей среды.
Заметка обновлена 12 ноября 2026: код проверен на актуальных версиях, добавлены современные варианты.

Читайте также