一、理解拷贝的本质：内存与引用的博弈

在JavaScript中，数据类型分为原始类型（Number、String、Boolean、Null、Undefined、Symbol、BigInt）和引用类型（Object、Array、Function等）。原始类型存储在栈内存中，直接按值访问；引用类型存储在堆内存中，变量保存的是内存地址的引用。

当执行let a = {name: 'John'}时，变量a保存的是对象在堆内存中的地址。若执行let b = a，实际上是将a的引用地址复制给b，此时a和b指向同一个对象，修改b.name会影响a.name。这种通过引用复制的方式称为浅拷贝，而创建完全独立新对象的过程称为深拷贝。

二、浅拷贝的实现方案与代码解析

1. 基础浅拷贝方法

1.1 Object.assign()

function shallowCopy(target) {
  return Object.assign({}, target);
}
// 示例
const obj = {a: 1, b: {c: 2}};
const copy = shallowCopy(obj);
copy.b.c = 3;
console.log(obj.b.c); // 输出3（嵌套对象被共享）

原理：将源对象的所有可枚举属性复制到目标对象，对于嵌套对象仍保持引用关系。

1.2 展开运算符

function shallowCopy(target) {
  return {...target};
}
// 效果与Object.assign()相同

1.3 数组专属方法

// 数组浅拷贝
const arr = [1, 2, {a: 3}];
const arrCopy1 = arr.slice();
const arrCopy2 = [...arr];
const arrCopy3 = Array.from(arr);
// 修改嵌套对象会互相影响

2. 浅拷贝的局限性

浅拷贝仅解决第一层属性的独立性问题，对于嵌套对象或数组，内部引用仍保持共享。这在处理复杂数据结构时可能导致意外修改。

三、深拷贝的完整实现方案

1. 递归实现深拷贝

function deepCopy(target, hash = new WeakMap()) {
  // 处理基本类型和null/undefined
  if (typeof target !== 'object' || target === null) {
    return target;
  }
  // 处理循环引用
  if (hash.has(target)) {
    return hash.get(target);
  }
  // 处理Date和RegExp
  if (target instanceof Date) return new Date(target);
  if (target instanceof RegExp) return new RegExp(target);
  // 创建新对象或数组
  const copy = Array.isArray(target) ? [] : {};
  hash.set(target, copy); // 记录已拷贝对象
  // 递归拷贝属性
  for (let key in target) {
    if (target.hasOwnProperty(key)) {
      copy[key] = deepCopy(target[key], hash);
    }
  }
  // 处理Symbol属性
  const symbolKeys = Object.getOwnPropertySymbols(target);
  for (let symKey of symbolKeys) {
    copy[symKey] = deepCopy(target[symKey], hash);
  }
  return copy;
}

关键点解析：

1. 类型判断：通过typeof和instanceof区分不同数据类型
2. 循环引用处理：使用WeakMap记录已拷贝对象，防止无限递归
3. 特殊对象处理：单独处理Date、RegExp等内置对象
4. Symbol属性支持：通过Object.getOwnPropertySymbols获取Symbol键
5. 性能优化：WeakMap避免内存泄漏，递归终止条件明确

2. 结构化克隆算法（浏览器环境）

现代浏览器提供structuredClone()API，支持大部分数据类型的深拷贝：

const original = {a: 1, b: new Date(), c: /regex/};
const cloned = structuredClone(original);

限制：

• 不支持Function、DOM节点等特殊对象
• 兼容性需考虑（IE不支持）

3. JSON序列化方案（简单场景）

function jsonDeepCopy(target) {
  return JSON.parse(JSON.stringify(target));
}
// 缺陷：
// 1. 无法处理函数、Symbol、undefined
// 2. 丢失对象原型链
// 3. 无法处理循环引用

四、实际应用中的选择策略

场景	推荐方案	注意事项
简单对象拷贝	Object.assign()/展开运算符	确认无嵌套引用
复杂对象深拷贝	递归实现或structuredClone	注意循环引用
性能敏感场景	定制化浅拷贝+必要属性深拷贝	权衡拷贝深度
浏览器环境	structuredClone	检查兼容性

五、性能优化与边界处理

1. 循环引用检测：必须使用WeakMap而非普通对象记录已拷贝对象
2. 大数据量优化：对于数组可考虑分块处理
3. 原型链保留：递归实现默认会丢失原型链，如需保留需额外处理：

   function deepCopyWithProto(target) {
   const copy = Object.create(Object.getPrototypeOf(target));
   // ...其余递归逻辑
   }

六、完整工具函数实现

const clone = {
  shallow(target) {
    if (Array.isArray(target)) return [...target];
    if (typeof target === 'object') return {...target};
    return target;
  },
  deep(target) {
    return this._deepCopy(target);
  },
  _deepCopy(target, hash = new WeakMap()) {
    // 基本类型处理
    if (typeof target !== 'object' || target === null) return target;
    // 循环引用处理
    if (hash.has(target)) return hash.get(target);
    // 特殊对象处理
    let copy;
    if (target instanceof Date) copy = new Date(target);
    else if (target instanceof RegExp) copy = new RegExp(target);
    else if (Array.isArray(target)) copy = [];
    else {
      // 保留原型链
      const proto = Object.getPrototypeOf(target);
      copy = Object.create(proto);
    }
    hash.set(target, copy);
    // 属性拷贝
    const allKeys = [
      ...Object.keys(target),
      ...Object.getOwnPropertySymbols(target)
    ];
    for (let key of allKeys) {
      copy[key] = this._deepCopy(target[key], hash);
    }
    return copy;
  }
};
// 使用示例
const complexObj = {
  date: new Date(),
  regex: /test/,
  array: [1, 2, {nested: 'obj'}],
  [Symbol('sym')]: 'symbolValue'
};
complexObj.self = complexObj; // 循环引用
const cloned = clone.deep(complexObj);
console.log(cloned !== complexObj); // true
console.log(cloned.array !== complexObj.array); // true
console.log(cloned.self === cloned); // true

七、总结与最佳实践

1. 明确需求：根据业务场景选择拷贝深度
2. 性能考量：大数据量时避免不必要的深拷贝
3. 边界处理：特别注意循环引用和特殊对象类型
4. 工具封装：将拷贝逻辑封装为可复用工具
5. 测试验证：通过单元测试验证拷贝正确性

掌握深浅拷贝的实现原理不仅能帮助开发者避免常见的引用错误，还能在需要优化性能或处理特殊数据结构时提供解决方案。建议在实际项目中根据具体需求选择或定制拷贝策略，并通过测试确保其正确性。