js怎么实现原型链的深拷贝

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