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 =
