JS中深拷贝表现为何不同？C++背景开发者的技术疑问

问题核心：JS与C++的对象拷贝逻辑完全不同 #

作为有C背景的开发者，你肯定习惯了对象默认的值语义——比如在C里，把一个类对象赋值给另一个，默认会触发拷贝构造函数做浅拷贝（深拷贝需自行实现），但至少是两个独立对象。但在JavaScript里，所有对象（包括类实例）都是引用类型，直接赋值、浅拷贝都不会创建真正独立的新对象，这就是你遇到问题的根源。

为什么你的数组里全是同一引用？ #

你提到“每次处理时深拷贝foo对象”，但很大概率你实际做的是浅拷贝甚至直接复用原引用：

• 如果直接修改原foo实例的属性再push到数组，数组里存的都是同一个对象的引用，每次修改都会覆盖之前的状态；
• 就算用了Object.assign({}, foo)或展开运算符{...foo}，这也只是浅拷贝——如果foo里有嵌套对象、数组，这些嵌套部分还是共享引用，修改它们仍会影响所有拷贝。

如何实现真正的深拷贝？ #

根据你的面向对象场景，推荐几种贴合需求的方案：

1. 在Foo类中实现clone方法（最符合OOP思想）

给Foo加一个clone方法，返回新的Foo实例并复制所有属性（包括嵌套属性）：

class Foo {
  constructor(id, nestedData) {
    this.id = id;
    this.nested = nestedData; // 假设有嵌套对象
  }

  // 实现深拷贝的clone方法
  clone() {
    // 对嵌套对象做深拷贝（简单场景用JSON方法，复杂场景用递归）
    const copiedNested = typeof this.nested === 'object' 
      ? JSON.parse(JSON.stringify(this.nested)) 
      : this.nested;
    // 返回新的Foo实例，而非原对象引用
    return new Foo(this.id, copiedNested);
  }
}

class DoSomething {
  constructor(fooInstance) {
    this.baseFoo = fooInstance;
    this.fooArray = [];
  }

  processFoo(newId) {
    // 每次处理时克隆得到独立实例
    const copiedFoo = this.baseFoo.clone();
    copiedFoo.id = newId;
    // 修改的是新实例，原baseFoo不受影响
    this.fooArray.push(copiedFoo);
  }
}

// 测试
const baseFoo = new Foo(1, { value: 100 });
const handler = new DoSomething(baseFoo);
handler.processFoo(2);
handler.processFoo(3);

console.log(handler.fooArray[0].id); // 2
console.log(handler.fooArray[1].id); // 3
console.log(handler.fooArray[0].nested === handler.fooArray[1].nested); // false，嵌套对象也独立

2. 通用深拷贝函数（适合复杂场景）

如果Foo实例包含函数、Symbol或循环引用，JSON方法会失效，可写一个递归深拷贝函数：

function deepClone(obj) {
  // 处理基本类型和null
  if (obj === null || typeof obj !== 'object') return obj;
  
  // 处理数组
  if (obj instanceof Array) {
    return obj.map(item => deepClone(item));
  }
  
  // 处理普通对象/类实例
  const clonedObj = new obj.constructor(); // 用原构造函数创建新实例
  for (const key in obj) {
    if (obj.hasOwnProperty(key)) {
      clonedObj[key] = deepClone(obj[key]);
    }
  }
  return clonedObj;
}

// 使用时
const copiedFoo = deepClone(this.baseFoo);

3. 注意JSON方法的局限性

JSON.parse(JSON.stringify(obj))是最简单的深拷贝方式，但有几个坑：

• 会丢失函数、Symbol、undefined属性；
• 无法处理循环引用（对象引用自身）；
• 不能拷贝类实例的原型链，拷贝后会变成普通对象（不再是Foo实例）。

仅适合简单数据结构的Foo实例。

总结 #

JS没有C++那样的自动值拷贝，所有对象操作默认是引用传递。要实现深拷贝，必须显式创建新对象实例，并递归复制所有层级的属性，才能保证数组里的每个Foo实例独立，互不影响。

内容的提问来源于stack exchange，提问作者aa51