什么是深拷贝 - HAC's Blog

1. 什么是浅拷贝？#

浅拷贝只创建一个新的最外层对象，内部嵌套对象仍然与原对象共用。

例如：

1
const original = {
2
  taskName: "市场分析",
3
  user: {
4
    name: "Alice"
5
  }
6
};
7

8
const copy = { ...original };

此时：

1
original          copy
2
   │                │
3
   ├─ taskName      ├─ taskName
4
   │                │
5
   └──────┐   ┌─────┘
6
          ↓   ↓
7
     同一个 user 对象

修改最外层字段通常互不影响：

1
copy.taskName = "行业分析";
2

3
console.log(original.taskName);
4
// "市场分析"

但是修改嵌套对象会影响原对象：

1
copy.user.name = "Bob";
2

3
console.log(original.user.name);
4
// "Bob"

原因是 copy.user 和 original.user 指向同一份内存数据。

2. 什么是深拷贝？#

深拷贝不仅复制最外层对象，还递归复制内部所有嵌套对象和数组。

1
const deepCopy = structuredClone(original);

可以理解为：

1
original                    deepCopy
2
   │                           │
3
   └─ user 对象 A              └─ user 对象 B
4

5
对象 A 和对象 B 内容相同，但彼此独立

现在修改副本：

1
deepCopy.user.name = "Carol";
2

3
console.log(original.user.name);
4
// 不会变成 "Carol"

因此，并行任务各自拿到深拷贝后，即使修改嵌套内容，也不会直接影响原始 Context 或其他任务的副本。

3. 浅拷贝和深拷贝的区别#

假设原数据是：

1
const context = {
2
  step: 1,
3
  data: {
4
    items: ["A", "B"]
5
  }
6
};

3.1 浅拷贝#

1
const copy = { ...context };
2
copy.data.items.push("C");

结果可能是：

1
context.data.items
2
// ["A", "B", "C"]

虽然修改的是 copy，但原数据也变了，因为嵌套的 data 和 items 仍然共享。

3.2 深拷贝#

1
const copy = structuredClone(context);
2
copy.data.items.push("C");

结果是：

1
context.data.items
2
// ["A", "B"]
3

4
copy.data.items
5
// ["A", "B", "C"]

二者已经完全独立。

对比	浅拷贝	深拷贝
最外层对象	独立	独立
嵌套对象和数组	通常共享	独立
修改嵌套数据	可能影响原数据	不影响原数据
性能和内存开销	较小	较大
适合情况	数据严格只读或结构简单	任务确实需要修改副本

4. 为什么“浅拷贝 + 只读”也可以安全？#

这是我们在步骤并行化里提到过的做法。虽然浅拷贝仍然共享嵌套对象，但只要所有并行任务都遵守：

1
可以读取，不可以修改

就不会发生并发覆盖。例如：

1
// 安全：只读取
2
const count = localContext.searchResults.length;
3

4
// 不安全：修改了共享的嵌套数组
5
localContext.searchResults.push(newResult);

所以常见设计是：

1
前序数据：不可变，只允许读取
2
并行步骤的新结果：通过 return 单独返回
3
调度器：等待步骤结束后统一合并

这通常比给每个任务深拷贝一份大型 Context 更节省内存和时间。

总之：

前序数据是并行步骤开始前，上游已经确定的共享输入；浅拷贝只复制外壳，内部数据仍可能共享；深拷贝连内部嵌套数据也复制，因此副本之间更加独立，但成本也更高。

音乐

音乐