JS原型链深拷贝实现详解

最近发现不少小伙伴都对文章很感兴趣，所以今天继续给大家介绍文章相关的知识，本文《JS原型链深拷贝实现方法》主要内容涉及到等等知识点，希望能帮到你！当然如果阅读本文时存在不同想法，可以在评论中表达，但是请勿使用过激的措辞~

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!

为什么常规的深拷贝不直接复制原型链上的属性？

当我们谈论对象的深拷贝时，关注点通常在于复制对象“自身”的数据，而不是它从原型链上继承来的属性。这背后的逻辑是多方面的。

首先，原型链上的属性，尤其是方法，是共享的。它们是定义在构造函数或类原型上的，所有实例都引用同一个函数或值。如果深拷贝连同这些共享属性也一并复制到新对象的自身属性中，那么：

1. 内存浪费： 每个新对象都会拥有自己独立的方法副本，而不是共享同一个方法，这会显著增加内存开销，尤其是在有大量实例时。
2. 行为不一致： 如果你修改了原型的某个方法，所有共享该原型的现有实例的行为都会随之改变。但如果你深拷贝了这些方法，新对象的方法副本将不会受到原型更新的影响，这可能会导致预期之外的行为差异。
3. 违背继承原则： 继承的本质就是通过原型链共享代码和数据。强行复制它们就打破了这种共享机制。

因此，一个标准的深拷贝实现，会使用 Object.prototype.hasOwnProperty.call(obj, key) 这样的检查来确保只复制对象“自身”的属性。它关注的是实例特有的数据，而非其类型层面的共享行为。

如何处理包含自定义类实例的深拷贝？

深拷贝自定义类实例确实是个让人头疼的问题，因为简单的 Object.create(Object.getPrototypeOf(obj)) 加上属性遍历，虽然能保留原型链，让 instanceof 判断依然有效，并且能访问原型上的方法，但它有一个致命的缺陷：它不会执行构造函数。

这意味着，如果你的类构造函数中包含了一些重要的初始化逻辑，比如设置默认值、绑定事件监听器、或者执行一些副作用操作，这些逻辑在深拷贝后将不会被触发。新创建的克隆对象可能处于一个不完整的或不一致的状态。

对于这种情况，我的建议是：

1. 在类内部实现 clone 方法： 这是最可靠也最推荐的做法。让类自己知道如何正确地复制自己。

   class MyComplexClass {
       constructor(id, data) {
           this.id =

以上就是《JS原型链深拷贝实现详解》的详细内容，更多关于JavaScript,原型链,深拷贝,循环引用,自定义类的资料请关注golang学习网公众号！