深克隆和浅克隆区别是什么？

胖雪吖_7130

发布时间：2025-08-30 08:05:01

316人浏览过

来源于php中文网

原创

深克隆和浅克隆的区别在于拷贝的深度：浅克隆只复制对象第一层属性，嵌套对象共享引用，修改克隆对象会影响原始对象；深克隆递归复制所有层级，生成完全独立的对象。浅克隆速度快，适用于简单结构；深克隆性能开销大，但能保证彻底隔离。选择方式需权衡对象结构、性能和功能需求。

深克隆和浅克隆区别是什么？

深克隆和浅克隆，简单来说，区别就在于拷贝的深度。浅克隆只复制对象的引用，而深克隆会创建一个全新的对象，包括所有嵌套的对象。

浅克隆，速度快，但修改克隆对象会影响原始对象。深克隆，速度慢，但克隆对象和原始对象完全独立。

深克隆和浅克隆的区别是什么？

为什么需要克隆？

克隆，或者说复制对象，在编程中非常常见。想象一下，你有一个复杂的配置对象，需要在多个地方使用，但每个地方可能需要稍微修改一下。如果直接传递原始对象，修改一处就会影响所有地方。这时候，克隆就派上用场了。它允许你创建对象的副本，这样就可以安全地修改副本，而不会影响原始对象。

另外，在处理不可变对象时，克隆也是一种常见的模式。虽然不可变对象本身不能被修改，但我们可以通过克隆来创建一个新的、修改后的对象。

浅克隆的实现方式和局限性

浅克隆，顾名思义，只复制对象的第一层属性。如果对象包含嵌套的对象（例如，对象中的属性也是一个对象），那么浅克隆只会复制嵌套对象的引用，而不是创建一个新的嵌套对象。

在 JavaScript 中，可以使用

Object.assign()

或扩展运算符 (

...

) 来实现浅克隆：

const originalObject = {
  name: 'Original',
  details: {
    age: 30
  }
};

// 使用 Object.assign() 浅克隆
const shallowClone1 = Object.assign({}, originalObject);

// 使用扩展运算符浅克隆
const shallowClone2 = { ...originalObject };

shallowClone1.name = 'Clone1';
shallowClone1.details.age = 35; // 注意：这里会影响 originalObject

console.log(originalObject.name); // 输出 "Original"
console.log(originalObject.details.age); // 输出 35，被修改了！

可以看到，修改

shallowClone1.name

不会影响

originalObject.name

，因为

name

是原始对象的第一层属性。但是，修改

shallowClone1.details.age

会影响

originalObject.details.age

，因为

details

是一个嵌套对象，浅克隆只复制了它的引用。

这就是浅克隆的局限性：它只能保证第一层属性的独立性，对于嵌套对象，克隆对象和原始对象仍然共享同一个引用。

java-api-doc-generator

分析 Java Spring Boot 后端 Controller 代码，自动生成 Markdown 格式的接口文档。当用户说“生成 Java 接口文档”、“生成 API 文档”、“从 Spring 代码生成文档”时触发。

下载

深克隆的实现方式和性能考量

深克隆会递归地复制对象的所有属性，包括嵌套对象，从而创建一个完全独立的对象。实现深克隆的方法有很多种，其中最简单粗暴的方式是使用

JSON.parse(JSON.stringify(object))

：

const originalObject = {
  name: 'Original',
  details: {
    age: 30
  }
};

// 使用 JSON.parse(JSON.stringify()) 深克隆
const deepClone = JSON.parse(JSON.stringify(originalObject));

deepClone.name = 'DeepClone';
deepClone.details.age = 40;

console.log(originalObject.name); // 输出 "Original"
console.log(originalObject.details.age); // 输出 30，没有被修改！

这种方法简单易懂，但是存在一些问题：

无法处理循环引用： 如果对象中存在循环引用（例如，对象 A 的属性指向对象 B，而对象 B 的属性又指向对象 A），
```
JSON.stringify()
```
会抛出错误。
无法处理函数和
undefined
：
```
JSON.stringify()
```
会忽略函数和值为
```
undefined
```
的属性。
性能问题： 对于大型对象，
```
JSON.stringify()
```
和
```
JSON.parse()
```
的性能开销比较大。

更健壮的深克隆实现需要递归地遍历对象的属性，并根据属性的类型进行不同的处理。例如，对于基本类型，直接复制值；对于对象类型，递归调用深克隆函数；对于数组类型，创建一个新的数组并递归复制数组中的元素。

function deepClone(obj, cache = new WeakMap()) {
  if (obj === null || typeof obj !== "object") {
    return obj;
  }

  if (cache.has(obj)) {
    return cache.get(obj);
  }

  let clonedObj = Array.isArray(obj) ? [] : {};
  cache.set(obj, clonedObj);

  for (let key in obj) {
    if (obj.hasOwnProperty(key)) {
      clonedObj[key] = deepClone(obj[key], cache);
    }
  }

  return clonedObj;
}

const originalObject = {
  name: 'Original',
  details: {
    age: 30
  },
  func: function() { console.log("hello"); },
  arr: [1, 2, 3]
};

originalObject.circularReference = originalObject; // 添加循环引用

const deepCloneObject = deepClone(originalObject);

deepCloneObject.name = 'DeepClone';
deepCloneObject.details.age = 40;
deepCloneObject.arr.push(4);

console.log(originalObject.name); // 输出 "Original"
console.log(originalObject.details.age); // 输出 30
console.log(originalObject.arr); // 输出 [1, 2, 3]
console.log(deepCloneObject.func); // 输出 undefined，函数没有被克隆
console.log(deepCloneObject.circularReference === deepCloneObject); // true，循环引用被正确处理

这个实现使用