一文读懂Javascript深拷贝与浅拷贝

 前言

在 javascript 中有不同的方法来复制对象，如果你还不熟悉这门语言的话，复制对象时就会很容易掉进陷阱里，那么我们怎样才能正确地复制一个对象呢?

创新互联公司自2013年起，是专业互联网技术服务公司，拥有项目网站建设、成都网站制作网站策划，项目实施与项目整合能力。我们以让每一个梦想脱颖而出为使命，1280元子长做网站,已为上家服务,为子长各地企业和个人服务,联系电话:028-86922220

读完本文，希望你能明白：

  • 什么是深/浅拷贝，他们跟赋值有何区别?
  • 深/浅拷贝的实现方式有几种?

浅拷贝与深拷贝

  • 浅拷贝是创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值，如果属性是引用类型，拷贝的就是内存地址 ，所以如果其中一个对象改变了这个地址，就会影响到另一个对象。
  • 深拷贝是将一个对象从内存中完整的拷贝一份出来,从堆内存中开辟一个新的区域存放新对象,且修改新对象不会影响原对象。

 

 
 
 
 
    
  
  
  
  
  1. var a1 = {b: {c: {}}; 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. var a2 = shallowClone(a1); // 浅拷贝方法 
    4. 
  
  
  
  
  4. a2.b.c === a1.b.c // true 新旧对象还是共享同一块内存 
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6. var a3 = deepClone(a3); // 深拷贝方法 
    7. 
  
  
  
  
  7. a3.b.c === a1.b.c // false 新对象跟原对象不共享内存 
    8.

借助ConardLi大佬以下两张图片，帮我们更好的理解两者的含义：

 

 

总而言之，浅拷贝只复制指向某个对象的指针，而不复制对象本身，新旧对象还是共享同一块内存。但深拷贝会另外创造一个一模一样的对象，新对象跟原对象不共享内存，修改新对象不会改到原对象。

赋值和深/浅拷贝的区别

这三者的区别如下，不过比较的前提都是针对引用类型：

  • 当我们把一个对象赋值给一个新的变量时，赋的其实是该对象的在栈中的地址，而不是堆中的数据。也就是两个对象指向的是同一个存储空间，无论哪个对象发生改变，其实都是改变的存储空间的内容，因此，两个对象是联动的。
  • 浅拷贝：重新在堆中创建内存，拷贝前后对象的基本数据类型互不影响，但拷贝前后对象的引用类型因共享同一块内存，会相互影响。
  • 深拷贝：从堆内存中开辟一个新的区域存放新对象，对对象中的子对象进行递归拷贝,拷贝前后的两个对象互不影响。

我们先来看下面的例子，对比赋值与深/浅拷贝得到的对象修改后对原始对象的影响：

 
 
 
 
    
  
  
  
  
  1. // 对象赋值 
    2. 
  
  
  
  
  2. let obj1 = { 
    3. 
  
  
  
  
  3.     name : '浪里行舟', 
    4. 
  
  
  
  
  4.     arr : [1,[2,3],4], 
    5. 
  
  
  
  
  5. }; 
    6. 
  
  
  
  
  6. let obj2 = obj1; 
    7. 
  
  
  
  
  7. obj2.name = "阿浪"; 
    8. 
  
  
  
  
  8. obj2.arr[1] =[5,6,7] ; 
    9. 
  
  
  
  
  9. console.log('obj1',obj1)  
    10. 
  
  
  
  
  10. // obj1 { name: '阿浪', arr: [ 1, [ 5, 6, 7 ], 4 ] } 
    11. 
  
  
  
  
  11. console.log('obj2',obj2)  
    12. 
  
  
  
  
  12. // obj2 { name: '阿浪', arr: [ 1, [ 5, 6, 7 ], 4 ] } 
    13.

 

 
 
 
 
    
  
  
  
  
  1. // 浅拷贝 
    2. 
  
  
  
  
  2. let obj1 = { 
    3. 
  
  
  
  
  3.     name : '浪里行舟', 
    4. 
  
  
  
  
  4.     arr : [1,[2,3],4], 
    5. 
  
  
  
  
  5. }; 
    6. 
  
  
  
  
  6. let obj3=shallowClone(obj1) 
    7. 
  
  
  
  
  7. obj3.name = "阿浪"; 
    8. 
  
  
  
  
  8. obj3.arr[1] = [5,6,7] ; // 新旧对象还是共享同一块内存 
    9. 
  
  
  
  
  9. // 这是个浅拷贝的方法 
    10. 
  
  
  
  
  10. function shallowClone(source) { 
    11. 
  
  
  
  
  11.     var target = {}; 
    12. 
  
  
  
  
  12.     for(var i in source) { 
    13. 
  
  
  
  
  13.         if (source.hasOwnProperty(i)) { 
    14. 
  
  
  
  
  14.             target[i] = source[i]; 
    15. 
  
  
  
  
  15.         } 
    16. 
  
  
  
  
  16.     } 
    17. 
  
  
  
  
  17.     return target; 
    18. 
  
  
  
  
  18. } 
    19. 
  
  
  
  
  19. console.log('obj1',obj1)  
    20. 
  
  
  
  
  20. // obj1 { name: '浪里行舟', arr: [ 1, [ 5, 6, 7 ], 4 ] } 
    21. 
  
  
  
  
  21. console.log('obj3',obj3)  
    22. 
  
  
  
  
  22. // obj3 { name: '阿浪', arr: [ 1, [ 5, 6, 7 ], 4 ] } 
    23.

 

 
 
 
 
    
  
  
  
  
  1. // 深拷贝 
    2. 
  
  
  
  
  2. let obj1 = { 
    3. 
  
  
  
  
  3.     name : '浪里行舟', 
    4. 
  
  
  
  
  4.     arr : [1,[2,3],4], 
    5. 
  
  
  
  
  5. }; 
    6. 
  
  
  
  
  6. let obj4=deepClone(obj1) 
    7. 
  
  
  
  
  7. obj4.name = "阿浪"; 
    8. 
  
  
  
  
  8. obj4.arr[1] = [5,6,7] ; // 新对象跟原对象不共享内存 
    9. 
  
  
  
  
  9. // 这是个深拷贝的方法 
    10. 
  
  
  
  
  10. function deepClone(obj) { 
    11. 
  
  
  
  
  11.     if (obj === null) return obj;  
    12. 
  
  
  
  
  12.     if (obj instanceof Date) return new Date(obj); 
    13. 
  
  
  
  
  13.     if (obj instanceof RegExp) return new RegExp(obj); 
    14. 
  
  
  
  
  14.     if (typeof obj !== "object") return obj; 
    15. 
  
  
  
  
  15.     let cloneObj = new obj.constructor(); 
    16. 
  
  
  
  
  16.     for (let key in obj) { 
    17. 
  
  
  
  
  17.       if (obj.hasOwnProperty(key)) { 
    18. 
  
  
  
  
  18.         // 实现一个递归拷贝 
    19. 
  
  
  
  
  19.         cloneObj[key] = deepClone(obj[key]); 
    20. 
  
  
  
  
  20.       } 
    21. 
  
  
  
  
  21.     } 
    22. 
  
  
  
  
  22.     return cloneObj; 
    23. 
  
  
  
  
  23. } 
    24. 
  
  
  
  
  24. console.log('obj1',obj1)  
    25. 
  
  
  
  
  25. // obj1 { name: '浪里行舟', arr: [ 1, [ 2, 3 ], 4 ] } 
    26. 
  
  
  
  
  26. console.log('obj4',obj4)  
    27. 
  
  
  
  
  27. // obj4 { name: '阿浪', arr: [ 1, [ 5, 6, 7 ], 4 ] } 
    28.

上面例子中，obj1是原始对象，obj2是赋值操作得到的对象，obj3浅拷贝得到的对象，obj4深拷贝得到的对象，通过下面的表格，我们可以很清晰看到他们对原始数据的影响：

 

浅拷贝的实现方式

1.Object.assign()

Object.assign() 方法可以把任意多个的源对象自身的可枚举属性拷贝给目标对象，然后返回目标对象。

 
 
 
 
    
  
  
  
  
  1. let obj1 = { person: {name: "kobe", age: 41},sports:'basketball' }; 
    2. 
  
  
  
  
  2. let obj2 = Object.assign({}, obj1); 
    3. 
  
  
  
  
  3. obj2.person.name = "wade"; 
    4. 
  
  
  
  
  4. obj2.sports = 'football' 
    5. 
  
  
  
  
  5. console.log(obj1);  
    6. 
  
  
  
  
  6. // { person: { name: 'wade', age: 41 }, sports: 'basketball' } 
    7.

2.函数库lodash的_.clone方法

该函数库也有提供_.clone用来做 Shallow Copy,后面我们会再介绍利用这个库实现深拷贝。

 
 
 
 
    
  
  
  
  
  1. var _ = require('lodash'); 
    2. 
  
  
  
  
  2. var obj1 = { 
    3. 
  
  
  
  
  3.     a: 1, 
    4. 
  
  
  
  
  4.     b: { f: { g: 1 } }, 
    5. 
  
  
  
  
  5.     c: [1, 2, 3] 
    6. 
  
  
  
  
  6. }; 
    7. 
  
  
  
  
  7. var obj2 = _.clone(obj1); 
    8. 
  
  
  
  
  8. console.log(obj1.b.f === obj2.b.f); 
    9. 
  
  
  
  
  9. // true 
    10.

3.展开运算符...

展开运算符是一个 es6 / es2015特性，它提供了一种非常方便的方式来执行浅拷贝，这与 Object.assign ()的功能相同。

 
 
 
 
    
  
  
  
  
  1. let obj1 = { name: 'Kobe', address:{x:100,y:100}} 
    2. 
  
  
  
  
  2. let obj2= {... obj1} 
    3. 
  
  
  
  
  3. obj1.address.x = 200; 
    4. 
  
  
  
  
  4. obj1.name = 'wade' 
    5. 
  
  
  
  
  5. console.log('obj2',obj2)  
    6. 
  
  
  
  
  6. // obj2 { name: 'Kobe', address: { x: 200, y: 100 } } 
    7.

4.Array.prototype.concat()

 
 
 
 
    
  
  
  
  
  1. let arr = [1, 3, { 
    2. 
  
  
  
  
  2.     username: 'kobe' 
    3. 
  
  
  
  
  3.     }]; 
    4. 
  
  
  
  
  4. let arr2 = arr.concat();     
    5. 
  
  
  
  
  5. arr2[2].username = 'wade'; 
    6. 
  
  
  
  
  6. console.log(arr);  
    7. 
  
  
  
  
  7. //[ 1, 3, { username: 'wade' } ] 
    8.

5.Array.prototype.slice()

 
 
 
 
    
  
  
  
  
  1. let arr = [1, 3, { 
    2. 
  
  
  
  
  2.     username: ' kobe' 
    3. 
  
  
  
  
  3.     }]; 
    4. 
  
  
  
  
  4. let arr3 = arr.slice(); 
    5. 
  
  
  
  
  5. arr3[2].username = 'wade' 
    6. 
  
  
  
  
  6. console.log(arr);  
    7. 
  
  
  
  
  7. // [ 1, 3, { username: 'wade' } ] 
    8.

深拷贝的实现方式

1.JSON.parse(JSON.stringify())

 
 
 
 
    
  
  
  
  
  1. let arr = [1, 3, { 
    2. 
  
  
  
  
  2.     username: ' kobe' 
    3. 
  
  
  
  
  3. }]; 
    4. 
  
  
  
  
  4. let arr4 = JSON.parse(JSON.stringify(arr)); 
    5. 
  
  
  
  
  5. arr4[2].username = 'duncan';  
    6. 
  
  
  
  
  6. console.log(arr, arr4) 
    7.

 

这也是利用JSON.stringify将对象转成JSON字符串，再用JSON.parse把字符串解析成对象，一去一来，新的对象产生了，而且对象会开辟新的栈，实现深拷贝。

这种方法虽然可以实现数组或对象深拷贝,但不能处理函数和正则，因为这两者基于JSON.stringify和JSON.parse处理后，得到的正则就不再是正则(变为空对象)，得到的函数就不再是函数(变为null)了。

比如下面的例子：

 
 
 
 
    
  
  
  
  
  1. let arr = [1, 3, { 
    2. 
  
  
  
  
  2.     username: ' kobe' 
    3. 
  
  
  
  
  3. },function(){}]; 
    4. 
  
  
  
  
  4. let arr4 = JSON.parse(JSON.stringify(arr)); 
    5. 
  
  
  
  
  5. arr4[2].username = 'duncan';  
    6. 
  
  
  
  
  6. console.log(arr, arr4) 
    7.

 

 

2.函数库lodash的_.cloneDeep方法

该函数库也有提供_.cloneDeep用来做 Deep Copy

 
 
 
 
    
  
  
  
  
  1. var _ = require('lodash'); 
    2. 
  
  
  
  
  2. var obj1 = { 
    3. 
  
  
  
  
  3.     a: 1, 
    4. 
  
  
  
  
  4.     b: { f: { g: 1 } }, 
    5. 
  
  
  
  
  5.     c: [1, 2, 3] 
    6. 
  
  
  
  
  6. }; 
    7. 
  
  
  
  
  7. var obj2 = _.cloneDeep(obj1); 
    8. 
  
  
  
  
  8. console.log(obj1.b.f === obj2.b.f); 
    9. 
  
  
  
  
  9. // false 
    10.

3.jQuery.extend()方法

jquery 有提供一個$.extend可以用来做 Deep Copy

 
 
 
 
    
  
  
  
  
  1. $.extend(deepCopy, target, object1, [objectN])//第一个参数为true,就是深拷贝 
    2.

 

 
 
 
 
    
  
  
  
  
  1. var $ = require('jquery'); 
    2. 
  
  
  
  
  2. var obj1 = { 
    3. 
  
  
  
  
  3.     a: 1, 
    4. 
  
  
  
  
  4.     b: { f: { g: 1 } }, 
    5. 
  
  
  
  
  5.     c: [1, 2, 3] 
    6. 
  
  
  
  
  6. }; 
    7. 
  
  
  
  
  7. var obj2 = $.extend(true, {}, obj1); 
    8. 
  
  
  
  
  8. console.log(obj1.b.f === obj2.b.f);  
    9. 
  
  
  
  
  9. // false 
    10.

4.手写递归方法

递归方法实现深度克隆原理：遍历对象、数组直到里边都是基本数据类型，然后再去复制，就是深度拷贝。

有种特殊情况需注意就是对象存在循环引用的情况，即对象的属性直接的引用了自身的情况，解决循环引用问题，我们可以额外开辟一个存储空间，来存储当前对象和拷贝对象的对应关系，当需要拷贝当前对象时，先去存储空间中找，有没有拷贝过这个对象，如果有的话直接返回，如果没有的话继续拷贝，这样就巧妙化解的循环引用的问题。关于这块如有疑惑，请仔细阅读ConardLi大佬如何写出一个惊艳面试官的深拷贝?这篇文章。

 
 
 
 
    
  
  
  
  
  1. function deepClone(obj, hash = new WeakMap()) { 
    2. 
  
  
  
  
  2.   if (obj === null) return obj;  
    3. 
  
  
  
  
  3.   // 如果是null或者undefined我就不进行拷贝操作 
    4. 
  
  
  
  
  4.   if (obj instanceof Date) return new Date(obj); 
    5. 
  
  
  
  
  5.   if (obj instanceof RegExp) return new RegExp(obj); 
    6. 
  
  
  
  
  6.   // 可能是对象或者普通的值  如果是函数的话是不需要深拷贝 
    7. 
  
  
  
  
  7.   if (typeof obj !== "object") return obj; 
    8. 
  
  
  
  
  8.   // 是对象的话就要进行深拷贝 
    9. 
  
  
  
  
  9.   if (hash.get(obj)) return hash.get(obj); 
    10. 
  
  
  
  
  10.   let cloneObj = new obj.constructor(); 
    11. 
  
  
  
  
  11.   // 找到的是所属类原型上的constructor,而原型上的 constructor指向的是当前类本身 
    12. 
  
  
  
  
  12.   hash.set(obj, cloneObj); 
    13. 
  
  
  
  
  13.   for (let key in obj) { 
    14. 
  
  
  
  
  14.     if (obj.hasOwnProperty(key)) { 
    15. 
  
  
  
  
  15.       // 实现一个递归拷贝 
    16. 
  
  
  
  
  16.       cloneObj[key] = deepClone(obj[key], hash); 
    17. 
  
  
  
  
  17.     } 
    18. 
  
  
  
  
  18.   } 
    19. 
  
  
  
  
  19.   return cloneObj; 
    20. 
  
  
  
  
  20. } 
    21. 
  
  
  
  
  21. let obj = { name: 1, address: { x: 100 } }; 
    22. 
  
  
  
  
  22. obj.o = obj; // 对象存在循环引用的情况 
    23. 
  
  
  
  
  23. let d = deepClone(obj); 
    24. 
  
  
  
  
  24. obj.address.x = 200; 
    25. 
  
  
  
  
  25. console.log(d); 
    26.

分享题目：一文读懂Javascript深拷贝与浅拷贝
当前地址：http://www.csdahua.cn/qtweb/news11/57061.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

网站建设知识

同城分类信息

都江堰网站建设　　 　四川内江电信机房　　 　品牌网站建设　　 　成都免费做网站　　 　响应式建站　　 　什邡做网站　　 　资阳做网站　　 　成都定制网站　　 　LED显示屏　　 　成都广告招牌　　 　四川雅安服务器托管　　 　成都网站建设公司　　 　新津网站运维　　 　成都服务器租赁　　 　堡垒主机　　 　全网营销网站推广　　 　免备案空间腾讯云　　 　东电技服　　 　企业营销型网站　　 　和县翔豪网站