Коротко — суть:
- Поверхностное (shallow) копирование копирует только сами ссылки на поля верхнего уровня; вложенные объекты/массивы остаются общими между копией и оригиналом.
- Глубокое (deep) копирование рекурсивно создаёт новые объекты для всех вложенных структур, поэтому изменение вложенных частей не затрагивает оригинал.
JavaScript
- Пример поведения при shallow copy:
```
const orig = { a: 1, b: { c: 2 } };
const shallow = Object.assign({}, orig); // или {...orig}
shallow.b.c = 3;
console.log(orig.b.c); // 3 — вложенный объект общий
```
- Способы глубокого копирования:
- Современный и предпочтительный: `structuredClone(orig)` — поддерживает многие типы и циклические ссылки.
- Быстрый, но ограниченный: `JSON.parse(JSON.stringify(obj))` — теряет функции, undefined, RegExp, Date, Map/Set, и сломается при циклах.
- Библиотеки: `_.cloneDeep(obj)` (lodash) — надёжно для обычных POJO.
- Своя рекурсивная реализация — при нужде учесть типы и циклы.
- Замечания: `structuredClone` лучше при наличии сложных/циклических структур; `JSON` — только для простых данных.
Python
- Поведение при shallow copy:
```
import copy
orig = {'a': 1, 'b': [2, 3]}
shallow = copy.copy(orig)
shallow['b'][0] = 99
print(orig['b'][0]) # 99 — вложенный список общий
```
- Глубокое копирование:
```
deep = copy.deepcopy(orig)
deep['b'][0] = 0
print(orig['b'][0]) # по‑прежнему 99
```
- Другие методы:
- `json.loads(json.dumps(obj))` — те же ограничения, что и в JS.
- Для пользовательских классов можно реализовать `__deepcopy__(self, memo)` для управления копированием.
- Замечания: `copy.deepcopy` корректно обрабатывает циклы и большинство встроенных типов; при сложных ресурсах (файлы, сокеты) предпочесть явное создание нового объекта.
Java
- Поведение при ссылочном (поверхностном) копировании:
- Присвоение ссылки копированием не создаёт новый объект:
```
class Node { int v; Node child; }
Node orig = new Node(); orig.v=1; orig.child = new Node(); orig.child.v=2;
Node shallow = orig; // просто ссылка
shallow.child.v = 3;
System.out.println(orig.child.v); // 3
```
- Метод `clone()` по умолчанию (super.clone()) даёт поверхностную копию полей (для object-полей копируются ссылки).
- Как делать глубокую копию:
- Реализовать собственный `clone()` с рекурсивным клонированием вложенных полей:
```
class Node implements Cloneable {
int v; Node child;
public Node clone() {
try {
Node c = (Node) super.clone();
if (this.child != null) c.child = this.child.clone();
return c;
} catch(CloneNotSupportedException e) { throw new AssertionError(); }
}
}
```
- Использовать copy-конструкторы, создающие новые вложенные объекты:
```
class Node {
int v; Node child;
Node(Node other) {
this.v = other.v;
this.child = (other.child == null) ? null : new Node(other.child);
}
}
```
- Сериализация: записать/считать объект через ObjectOutputStream/ObjectInputStream (класс должен реализовать Serializable) — даёт глубокую копию и поддерживает циклы, но медленно.
- Библиотеки: Apache Commons SerializationUtils.clone(obj) (через сериализацию) или специализированные фреймворки.
- Замечания:
- Для массивов: `Arrays.copyOf` для массивов объектов — копирует верхний уровень массива, но ссылки на элементы остаются (shallow для объектов, deep не делается).
- Глубокое копирование в Java требует явно клонирования вложенных полей либо использования сериализации/библиотек.
Общие рекомендации
- Для простых JSON‑подобных структур: `structuredClone` (JS) / `copy.deepcopy` (Python) / сериализация или copy‑constructor (Java).
- Учитывайте ограничения (функции, даты, регулярки, Map/Set, потоки, файлы, циклы).
- По производительности — глубокое копирование может быть дорого; там, где возможно, предпочитайте неизменяемые структуры или создавайте новые объекты явно (copy‑constructor / фабричный метод).