JavaScript深度克隆：实现高效、健壮与安全的复杂对象复制

function simpleDeepClone(obj) {
  // 1. 处理原始类型和null
  if (obj === null || typeof obj !== 'object') {
    return obj;
  }

  // 2. 处理数组
  if (Array.isArray(obj)) {
    const clonedArray = [];
    for (let i = 0; i < obj.length; i++) {
      clonedArray[i] = simpleDeepClone(obj[i]); // 递归克隆数组元素
    }
    return clonedArray;
  }

  // 3. 处理普通对象
  if (typeof obj === 'object') {
    const clonedObject = {};
    for (const key in obj) {
      // 确保只克隆对象自身的属性，而不是原型链上的属性
      if (Object.prototype.hasOwnProperty.call(obj, key)) {
        clonedObject[key] = simpleDeepClone(obj[key]); // 递归克隆对象属性
      }
    }
    return clonedObject;
  }

  // 理论上不会走到这里，但作为安全返回
  return obj;
}

// 示例使用
const originalObject = {
  name: 'Alice',
  details: {
    age: 30,
    hobbies: ['reading', 'coding', { sport: 'tennis' }]
  },
  isActive: true
};

const clonedObject = simpleDeepClone(originalObject);

console.log('原始对象:', originalObject);
console.log('克隆对象:', clonedObject);
console.log('原始对象 !== 克隆对象:', originalObject !== clonedObject); // true
console.log('原始对象.details !== 克隆对象.details:', originalObject.details !== clonedObject.details); // true
console.log('原始对象.details.hobbies[2] !== 克隆对象.details.hobbies[2]:', originalObject.details.hobbies[2] !== clonedObject.details.hobbies[2]); // true

// 修改克隆对象不会影响原始对象
clonedObject.details.age = 31;
clonedObject.details.hobbies[0] = 'swimming';
console.log('修改克隆对象后：');
console.log('原始对象.details.age:', originalObject.details.age); // 30
console.log('克隆对象.details.age:', clonedObject.details.age); // 31

// ... (simpleDeepClone 函数的开头部分不变)
function deepCloneWithSpecialTypes(obj, hash = new WeakMap()) {
  if (obj === null || typeof obj !== 'object') {
    return obj;
  }

  // 处理循环引用
  if (hash.has(obj)) {
    return hash.get(obj);
  }

  // 处理 Date 对象
  if (obj instanceof Date) {
    return new Date(obj);
  }

  // 处理 RegExp 对象
  if (obj instanceof RegExp) {
    return new RegExp(obj);
  }

  // ... (其余部分与 simpleDeepClone 类似，但在处理数组和对象时需要传递 hash)
  // 3. 处理数组
  if (Array.isArray(obj)) {
    const clonedArray = [];
    hash.set(obj, clonedArray); // 存储引用，防止循环引用
    for (let i = 0; i < obj.length; i++) {
      clonedArray[i] = deepCloneWithSpecialTypes(obj[i], hash);
    }
    return clonedArray;
  }

  // 4. 处理普通对象
  if (typeof obj === 'object') {
    const clonedObject = {};
    hash.set(obj, clonedObject); // 存储引用，防止循环引用
    for (const key in obj) {
      if (Object.prototype.hasOwnProperty.call(obj, key)) {
        clonedObject[key] = deepCloneWithSpecialTypes(obj[key], hash);
      }
    }
    return clonedObject;
  }

  return obj;
}

function robustDeepClone(obj, hash = new WeakMap()) {
  // 1. 处理原始类型和null
  if (obj === null || typeof obj !== 'object') {
    return obj;
  }

  // 2. 处理循环引用
  // 如果当前对象已经被克隆过，直接返回其克隆副本
  if (hash.has(obj)) {
    return hash.get(obj);
  }

  // 3. 处理特殊内置对象
  // Date 对象
  if (obj instanceof Date) {
    return new Date(obj);
  }
  // RegExp 对象
  if (obj instanceof RegExp) {
    return new RegExp(obj);
  }

  // 4. 初始化克隆对象（数组或普通对象）
  let clone;
  if (Array.isArray(obj)) {
    clone = [];
  } else {
    clone = {};
  }

  // 5. 将原始对象和其对应的空克隆对象存入hash，以处理循环引用
  // 这一步必须在递归克隆属性之前完成
  hash.set(obj, clone);

  // 6. 递归克隆属性
  if (Array.isArray(obj)) {
    for (let i = 0; i < obj.length; i++) {
      clone[i] = robustDeepClone(obj[i], hash);
    }
  } else {
    for (const key in obj) {
      if (Object.prototype.hasOwnProperty.call(obj, key)) {
        clone[key] = robustDeepClone(obj[key], hash);
      }
    }
  }

  return clone;
}

// 示例使用
const objA = {
  value: 1,
  date: new Date(),
  regex: /test/g,
  nested: {
    data: 'hello'
  },
  arr: [1, { a: 2 }, 3]
};
objA.selfRef = objA; // 引入循环引用

const clonedObjA = robustDeepClone(objA);

console.log('--- 健壮的深度克隆示例 ---');
console.log('原始对象:', objA);
console.log('克隆对象:', clonedObjA);

console.log('原始对象 === 克隆对象:', objA === clonedObjA); // false
console.log('原始对象.date === 克隆对象.date:', objA.date === clonedObjA.date); // false (Date对象被正确克隆)
console.log('原始对象.regex === 克隆对象.regex:', objA.regex === clonedObjA.regex); // false (RegExp对象被正确克隆)
console.log('原始对象.nested === 克隆对象.nested:', objA.nested === clonedObjA.nested); // false
console.log('原始对象.arr[1] === 克隆对象.arr[1]:', objA.arr[1] === clonedObjA.arr[1]); // false
console.log('原始对象.selfRef === 克隆对象.selfRef:', objA.selfRef === clonedObjA.selfRef); // true (循环引用被正确处理，指向克隆对象自身)
console.log('clonedObjA.selfRef === clonedObjA:', clonedObjA.selfRef === clonedObjA); // true

// 示例使用 structuredClone
const originalData = {
  id: 1,
  name: 'Product A',
  created: new Date(),
  config: new Map([['key1', 'value1'], ['key2', { nested: true }]]),
  items: new Set([1, 'item2', { data: 'test' }]),
  reg: /abc/i
};
originalData.self = originalData; // 引入循环引用

try {
  const clonedData = structuredClone(originalData);

  console.log('\n--- structuredClone 示例 ---');
  console.log('原始数据:', originalData);
  console.log('克隆数据:', clonedData);

  console.log('原始数据 === 克隆数据:', originalData === clonedData); // false
  console.log('原始数据.created === 克隆数据.created:', originalData.created === clonedData.created); // false
  console.log('原始数据.config === 克隆数据.config:', originalData.config === clonedData.config); // false
  console.log('原始数据.self === 克隆数据.self:', originalData.self === clonedData.self); // true (循环引用被正确处理)
  console.log('clonedData.self === clonedData:', clonedData.self === clonedData); // true

  // 尝试克隆包含函数的对象 (会报错)
  const objWithFunction = {
    id: 2,
    greet: () => console.log('Hello')
  };
  // structuredClone(objWithFunction); // 这行代码会抛出 DataCloneError
} catch (error) {
  console.error('\nstructuredClone 错误示例:', error.message);
}