JavaScript深度克隆：实现高效、健壮与安全的复杂对象复制-js教程-PHP中文网

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

深度克隆在javascript中是复制复杂对象时避免引用问题的关键技术。本文将深入探讨如何构建一个高效且健壮的深度克隆函数，涵盖基本类型、对象、数组、特殊内置对象（如date、regexp）以及循环引用等复杂场景。此外，还将介绍现代javascript内置的`structuredclone` api，并提供选择合适克隆方法的指导，确保数据操作的独立性与安全性。

引言：理解深度克隆的必要性

在JavaScript中，当我们复制一个对象或数组时，通常会遇到浅拷贝和深拷贝的概念。浅拷贝（如使用Object.assign({}, obj)、展开运算符{...obj}或Array.from(arr)）只会复制对象的第一层属性。如果对象中包含引用类型（如另一个对象或数组），浅拷贝只会复制其引用地址，而非实际内容。这意味着，修改拷贝后的嵌套对象会影响到原始对象，反之亦然，这在许多场景下会导致意想不到的副作用和数据不一致。

深度克隆（Deep Clone）则旨在创建一个全新的对象，其中包含原始对象所有嵌套属性的独立副本。无论嵌套层级有多深，深拷贝后的对象与原始对象之间完全独立，修改其中一个不会影响另一个。这对于状态管理、数据不可变性以及避免共享引用带来的bug至关重要。

基础递归实现：处理对象与数组

实现深度克隆的核心思想是递归。我们需要遍历对象的每一个属性，如果属性值是原始类型，则直接复制；如果属性值是引用类型（对象或数组），则递归调用克隆函数对其进行深度复制。

以下是一个处理基本类型、普通对象和数组的初步实现：

立即学习“Java免费学习笔记（深入）”；

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

登录后复制

这个基础实现能够满足大部分简单的深拷贝需求，但它仍存在一些局限性。

进阶考量：解决复杂场景

在实际应用中，对象可能包含更复杂的数据类型或结构，我们需要对这些情况进行特殊处理。

1. 处理特殊内置对象

JavaScript中有一些内置对象，如Date和RegExp，它们是对象类型，但不能简单地通过递归遍历其属性来克隆。它们需要通过其构造函数进行特殊处理。

// ... (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;
}

登录后复制

2. 避免循环引用

当对象内部存在相互引用时，即对象A引用了对象B，而对象B又引用了对象A，此时简单的递归克隆会导致无限循环，最终栈溢出。为了解决这个问题，我们需要一个机制来跟踪已经克隆过的对象。

笔魂AI

笔魂AI绘画-在线AI绘画、AI画图、AI设计工具软件

403

查看详情

常用的方法是使用WeakMap（或Map），在每次克隆一个对象之前，先检查它是否已经被克隆过。如果已经被克隆，则直接返回其对应的克隆副本；否则，在克隆之前将原始对象及其对应的空克隆对象存储到WeakMap中，然后进行递归克隆，最后返回克隆对象。这样，当再次遇到同一个对象时，可以直接从WeakMap中获取其克隆副本。

WeakMap的优势在于它对键是弱引用，这意味着如果键对象没有其他引用，垃圾回收器可以回收它，避免内存泄漏。

3. 处理其他数据类型

除了上述类型，JavaScript还有Map、Set、Function、Symbol、BigInt、Error以及DOM节点等。

Map和Set: 可以通过遍历其元素并递归克隆来处理。
Function: 函数通常不应该被克隆，因为它们的行为是固定的。通常直接返回原始函数。
Symbol和BigInt: 它们是原始类型，直接返回即可。
Error: 错误对象通常直接返回或创建新的错误实例。
DOM节点: DOM节点无法通过简单的JS逻辑进行深度克隆，需要使用Node.cloneNode(true)。
不可序列化对象: 某些对象（如Promise、WeakMap、WeakSet）是无法被深度克隆的。

对于本教程，我们将专注于最常见的对象、数组、Date、RegExp和循环引用。

构建健壮的深度克隆函数

综合以上考量，我们可以构建一个更健壮的deepClone函数：

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

登录后复制

这个robustDeepClone函数能够处理大多数常见的深度克隆场景，包括循环引用和一些内置对象。

现代JavaScript的解决方案：structuredClone

从ES2021开始，JavaScript引入了一个内置的全局函数structuredClone()，它提供了对可序列化JavaScript值进行深度克隆的标准方法。它基于结构化克隆算法，该算法在Web Workers中传递消息时使用，因此能够处理许多复杂的数据类型，并且通常比手动实现的递归克隆函数更高效和安全。

structuredClone的优势：

内置且高效: 由浏览器或Node.js环境原生实现，性能通常优于自定义JS代码。
处理更多类型: 除了基本类型、普通对象、数组、Date、RegExp，它还能处理Map、Set、ArrayBuffer、TypedArray、Blob、File、FileList、ImageData、DOMMatrix、AudioData、VideoFrame、ImageBitmap等多种复杂类型，并且能正确处理循环引用。
安全性: 不会执行任何代码，避免了原型链污染等安全问题。

structuredClone的局限性：

不支持函数: 函数不能被结构化克隆。尝试克隆函数会抛出DataCloneError。
不支持DOM节点: DOM节点不能被结构化克隆。
不支持不可序列化的对象: 例如Error对象（尽管某些环境可能支持），Promise、WeakMap、WeakSet等。
原型链丢失: 克隆后的对象会丢失其原始的原型链。例如，如果克隆一个自定义类的实例，得到的是一个普通对象，而不是该类的实例。

// 示例使用 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);
}

登录后复制