javascript中实现原型链的深拷贝，核心在于创建一个与原对象具有相同原型但属性完全独立的新对象，并递归复制所有自身可枚举属性，同时处理循环引用和特殊类型。1. 对于基本类型、null、undefined、symbol和函数，直接返回原值或引用；2. 使用weakmap记录已处理对象，防止循环引用；3. 对date、regexp、map、set等内置对象进行特判并正确构造；4. 数组通过遍历元素递归深拷贝；5. 普通对象和自定义类实例通过object.create继承原原型，并仅复制自身可枚举属性，从而保留instanceof行为但不执行构造函数。该方法确保新旧对象完全隔离，且支持复杂结构与原型链的保留，最终返回一个功能完整、数据独立的克隆对象。
JavaScript 中实现原型链的深拷贝，其核心在于创建一个全新的对象，这个新对象不仅复制了原对象自身的（非继承的）所有可枚举属性，还递归地复制了这些属性值中包含的复杂数据结构（如嵌套对象、数组、Map、Set等），确保新旧对象之间完全独立。同时，为了更贴近“原型链的深拷贝”这一说法，通常也会考虑让新对象继承与原对象相同的原型，但不会重新执行构造函数。此外，处理循环引用是深拷贝不可或缺的一环。
解决方案
要实现一个健壮的深拷贝函数，我们需要考虑多种数据类型、循环引用以及如何处理原型链。以下是一个我个人认为比较实用和全面的实现方式：
function deepClone(obj, map = new WeakMap()) { // 1. 处理基本类型、null、undefined、Symbol 和函数 // 这些类型或直接返回，或只复制引用（函数） if (obj === null || typeof obj !== 'object' || typeof obj === 'symbol') { return obj; } if (typeof obj === 'function') { // 通常情况下，函数我们只复制引用，因为函数的行为是固定的， // 且深拷贝函数内部状态（如闭包变量）通常没有意义或非常复杂。 return obj; } // 2. 避免循环引用：在递归开始前，先检查是否已处理过该对象 if (map.has(obj)) { return map.get(obj); } let clone; // 3. 处理特殊内置对象：Date, RegExp, Map, Set if (obj instanceof Date) { clone = new Date(obj.getTime()); } else if (obj instanceof RegExp) { // RegExp 构造函数接收 source 和 flags clone = new RegExp(obj.source, obj.flags); } else if (obj instanceof Map) { clone = new Map(); map.set(obj, clone); // 关键：先将空克隆对象存入map，处理循环引用 obj.forEach((value, key) => { clone.set(deepClone(key, map), deepClone(value, map)); }); return clone; } else if (obj instanceof Set) { clone = new Set(); map.set(obj, clone); // 关键：先将空克隆对象存入map，处理循环引用 obj.forEach(value => { clone.add(deepClone(value, map)); }); return clone; } else if (Array.isArray(obj)) { // 4. 处理数组 clone = []; map.set(obj, clone); // 关键：先将空克隆对象存入map，处理循环引用 obj.forEach((item, index) => { clone[index] = deepClone(item, map); }); } else { // 5. 处理普通对象和自定义类实例 // 尝试保留其原型链：创建一个新对象，其原型与原对象相同 // 这样做的好处是，如果原对象是某个类的实例，新对象也将“是”该类的实例（通过 instanceof 检查） // 并且可以访问原型上的方法。但请注意，这不会执行原对象的构造函数。 clone = Object.create(Object.getPrototypeOf(obj)); map.set(obj, clone); // 关键：先将空克隆对象存入map，处理循环引用 // 遍历并深拷贝对象自身的（非继承的）可枚举属性 // for...in 会遍历原型链上的可枚举属性，所以需要用 hasOwnProperty 过滤 for (let key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { clone[key] = deepClone(obj[key], map); } } } return clone; } // 示例用法： const originalObj = { a: 1, b: { c: 2, d: [3, 4], e: new Date(), f: /abc/g, g: new Map([['key1', 'val1']]), h: new Set([10, 20]) }, arr: [{ x: 100 }, { y: 200 }], func: () => console.log('hello'), sym: Symbol('test'), undef: undefined, nul: null }; originalObj.b.self = originalObj; // 制造循环引用 const clonedObj = deepClone(originalObj); console.log('Original:', originalObj); console.log('Cloned:', clonedObj); // 验证独立性 clonedObj.b.c = 999; clonedObj.arr[0].x = 888; clonedObj.b.g.set('key2', 'val2'); console.log('Original after modification:', originalObj.b.c); // 2 console.log('Cloned after modification:', clonedObj.b.c); // 999 console.log('Original arr[0].x:', originalObj.arr[0].x); // 100 console.log('Cloned arr[0].x:', clonedObj.arr[0].x); // 888 console.log('Original Map size:', originalObj.b.g.size); // 1 console.log('Cloned Map size:', clonedObj.b.g.size); // 2 // 验证原型链（如果原对象是实例） class MyClass { constructor(name) { this.name = name; } sayHello() { return `Hello, ${this.name}!`; } } const myInstance = new MyClass('World'); const clonedInstance = deepClone(myInstance); console.log(clonedInstance instanceof MyClass); // true (因为保留了原型) console.log(clonedInstance.name); // World console.log(clonedInstance.sayHello()); // Hello, World!
为什么常规的深拷贝不直接复制原型链上的属性？
当我们谈论对象的深拷贝时，关注点通常在于复制对象“自身”的数据，而不是它从原型链上继承来的属性。这背后的逻辑是多方面的。
首先，原型链上的属性，尤其是方法，是共享的。它们是定义在构造函数或类原型上的，所有实例都引用同一个函数或值。如果深拷贝连同这些共享属性也一并复制到新对象的自身属性中，那么：
- 内存浪费： 每个新对象都会拥有自己独立的方法副本，而不是共享同一个方法，这会显著增加内存开销，尤其是在有大量实例时。
- 行为不一致： 如果你修改了原型的某个方法，所有共享该原型的现有实例的行为都会随之改变。但如果你深拷贝了这些方法，新对象的方法副本将不会受到原型更新的影响，这可能会导致预期之外的行为差异。
- 违背继承原则： 继承的本质就是通过原型链共享代码和数据。强行复制它们就打破了这种共享机制。
因此，一个标准的深拷贝实现，会使用
Object.prototype.hasOwnProperty.call(obj, key)
这样的检查来确保只复制对象“自身”的属性。它关注的是实例特有的数据，而非其类型层面的共享行为。
如何处理包含自定义类实例的深拷贝？
深拷贝自定义类实例确实是个让人头疼的问题，因为简单的
Object.create(Object.getPrototypeOf(obj))
加上属性遍历，虽然能保留原型链，让
instanceof
判断依然有效，并且能访问原型上的方法，但它有一个致命的缺陷：它不会执行构造函数。
这意味着，如果你的类构造函数中包含了一些重要的初始化逻辑，比如设置默认值、绑定事件监听器、或者执行一些副作用操作，这些逻辑在深拷贝后将不会被触发。新创建的克隆对象可能处于一个不完整的或不一致的状态。
对于这种情况，我的建议是：
- 在类内部实现
clone
方法：
这是最可靠也最推荐的做法。让类自己知道如何正确地复制自己。class MyComplexClass { constructor(id, data) { this.id =
评论（已关闭）
评论已关闭