低门槛彻底理解JavaScript中的深拷贝和浅拷贝

在说深拷贝与浅拷贝前，我们先看两个简单的案例：

网站建设哪家好，找成都创新互联！专注于网页设计、网站建设、微信开发、微信小程序、集团企业网站建设等服务项目。为回馈新老客户创新互联还提供了沂南免费建站欢迎大家使用！

 
 
 
    
  
  
  
  1. //案例1  
    2.   
  
  
  2. var num1 = 1, num2 = num1;  
    3.   
  
  
  3. console.log(num1) //1  
    4.   
  
  
  4. console.log(num2) //1  
    5.   
  
  
  5. num2 = 2; //修改num2  
    6.   
  
  
  6. console.log(num1) //1  
    7.   
  
  
  7. console.log(num2) //2  
    8.   
  
  
  8. //案例2  
    9.   
  
  
  9. var obj1 = {x: 1, y: 2}, obj2 = obj1;  
    10.   
  
  
  10. console.log(obj1) //{x: 1, y: 2}  
    11.   
  
  
  11. console.log(obj2) //{x: 1, y: 2}  
    12.   
  
  
  12. obj2.x = 2; //修改obj2.x  
    13.   
  
  
  13. console.log(obj1) //{x: 2, y: 2}  
    14.   
  
  
  14. console.log(obj2) //{x: 2, y: 2} 
    15.

按照常规思维，obj1应该和num1一样，不会因为另外一个值的改变而改变，而这里的obj1 却随着obj2的改变而改变了。同样是变量，为什么表现不一样呢？这就要引入JS中基本类型和引用类型的概念了。

基本类型和引用类型

ECMAScript变量可能包含两种不同数据类型的值：基本类型值和引用类型值。基本类型值指的是那些保存在栈内存中的简单数据段，即这种值完全保存在内存中的一个位置。而引用类型值是指那些保存堆内存中的对象，意思是变量中保存的实际上只是一个指针，这个指针指向内存中的另一个位置，该位置保存对象。

打个比方，基本类型和引用类型在赋值上的区别可以按“连锁店”和“单店”来理解：基本类型赋值等于在一个新的地方安装连锁店的规范标准新开一个分店，新开的店与其他旧店互不相关，各自运营；而引用类型赋值相当于一个店有两把钥匙，交给两个老板同时管理，两个老板的行为都有可能对一间店的运营造成影响。

上面清晰明了的介绍了基本类型和引用类型的定义和区别。目前基本类型有：

Boolean、Null、Undefined、Number、String、Symbol，引用类型有：Object、Array、Function。之所以说“目前”，因为Symbol就是ES6才出来的，之后也可能会有新的类型出来。

再回到前面的案例，案例1中的值为基本类型，案例2中的值为引用类型。案例2中的赋值就是典型的浅拷贝，并且深拷贝与浅拷贝的概念只存在于引用类型。

深拷贝与浅拷贝

既然已经知道了深拷贝与浅拷贝的来由，那么该如何实现深拷贝？我们先分别看看Array和Object自有方法是否支持：

Array  

 
 
 
    
  
  
  
  1. var arr1 = [1, 2], arr2 = arr1.slice();  
    2.   
  
  
  2. console.log(arr1); //[1, 2]  
    3.   
  
  
  3. console.log(arr2); //[1, 2]  
    4.   
  
  
  4. arr2[0] = 3; //修改arr2  
    5.   
  
  
  5. console.log(arr1); //[1, 2]  
    6.   
  
  
  6. console.log(arr2); //[3, 2] 
    7.

此时，arr2的修改并没有影响到arr1，看来深拷贝的实现并没有那么难嘛。我们把arr1改成二维数组再来看看：

 
 
 
    
  
  
  
  1. var arr1 = [1, 2, [3, 4]], arr2 = arr1.slice();  
    2.   
  
  
  2. console.log(arr1); //[1, 2, [3, 4]]  
    3.   
  
  
  3. console.log(arr2); //[1, 2, [3, 4]]  
    4.   
  
  
  4. arr2[2][1] = 5;   
    5.   
  
  
  5. console.log(arr1); //[1, 2, [3, 5]]  
    6.   
  
  
  6. console.log(arr2); //[1, 2, [3, 5]] 
    7.

咦，arr2又改变了arr1，看来slice()只能实现一维数组的深拷贝。

具备同等特性的还有：concat、Array.from() 。

Object

1、Object.assign()

 
 
 
    
  
  
  
  1. var obj1 = {x: 1, y: 2}, obj2 = Object.assign({}, obj1);  
    2.   
  
  
  2. console.log(obj1) //{x: 1, y: 2}  
    3.   
  
  
  3. console.log(obj2) //{x: 1, y: 2}  
    4.   
  
  
  4. obj2.x = 2; //修改obj2.x  
    5.   
  
  
  5. console.log(obj1) //{x: 1, y: 2}  
    6.   
  
  
  6. console.log(obj2) //{x: 2, y: 2}  
    7.   
  
  
  7. var obj1 = {  
    8.   
  
  
  8.     x: 1,   
    9.   
  
  
  9.     y: {  
    10.   
  
  
  10.         m: 1  
    11.   
  
  
  11.     }  
    12.   
  
  
  12. };  
    13.   
  
  
  13. var obj2 = Object.assign({}, obj1);  
    14.   
  
  
  14. console.log(obj1) //{x: 1, y: {m: 1}}  
    15.   
  
  
  15. console.log(obj2) //{x: 1, y: {m: 1}}  
    16.   
  
  
  16. obj2.y.m = 2; //修改obj2.y.m  
    17.   
  
  
  17. console.log(obj1) //{x: 1, y: {m: 2}}  
    18.   
  
  
  18. console.log(obj2) //{x: 2, y: {m: 2}} 
    19.

经测试，Object.assign()也只能实现一维对象的深拷贝。

2、JSON.parse(JSON.stringify(obj))

 
 
 
    
  
  
  
  1. var obj1 = {  
    2.   
  
  
  2.     x: 1,   
    3.   
  
  
  3.     y: {  
    4.   
  
  
  4.         m: 1  
    5.   
  
  
  5.     }  
    6.   
  
  
  6. };  
    7.   
  
  
  7. var obj2 = JSON.parse(JSON.stringify(obj1));  
    8.   
  
  
  8. console.log(obj1) //{x: 1, y: {m: 1}}  
    9.   
  
  
  9. console.log(obj2) //{x: 1, y: {m: 1}}  
    10.   
  
  
  10. obj2.y.m = 2; //修改obj2.y.m  
    11.   
  
  
  11. console.log(obj1) //{x: 1, y: {m: 1}}  
    12.   
  
  
  12. console.log(obj2) //{x: 2, y: {m: 2}} 
    13.

JSON.parse(JSON.stringify(obj)) 看起来很不错，不过MDN文档 的描述有句话写的很清楚：

undefined、任意的函数以及 symbol 值，在序列化过程中会被忽略（出现在非数组对象的属性值中时）或者被转换成 null（出现在数组中时）。

我们再来把obj1改造下：

 
 
 
    
  
  
  
  1. var obj1 = {  
    2.   
  
  
  2.     x: 1,  
    3.   
  
  
  3.     y: undefined,  
    4.   
  
  
  4.     z: function add(z1, z2) {  
    5.   
  
  
  5.         return z1 + z2  
    6.   
  
  
  6.     },  
    7.   
  
  
  7.     a: Symbol("foo")  
    8.   
  
  
  8. };  
    9.   
  
  
  9. var obj2 = JSON.parse(JSON.stringify(obj1));  
    10.   
  
  
  10. console.log(obj1) //{x: 1, y: undefined, z: ƒ, a: Symbol(foo)}  
    11.   
  
  
  11. console.log(JSON.stringify(obj1)); //{"x":1}  
    12.   
  
  
  12. console.log(obj2) //{x: 1} 
    13.

发现，在将obj1进行JSON.stringify()序列化的过程中，y、z、a都被忽略了，也就验证了MDN文档的描述。既然这样，那JSON.parse(JSON.stringify(obj))的使用也是有局限性的，不能深拷贝含有undefined、function、symbol值的对象，不过JSON.parse(JSON.stringify(obj))简单粗暴，已经满足90%的使用场景了。

经过验证，我们发现JS 提供的自有方法并不能彻底解决Array、Object的深拷贝问题。只能祭出大杀器：递归

 
 
 
    
  
  
  
  1. function deepCopy(obj) {  
    2.   
  
  
  2.     // 创建一个新对象  
    3.   
  
  
  3.     let result = {}  
    4.   
  
  
  4.     let keys = Object.keys(obj),  
    5.   
  
  
  5.         key = null,  
    6.   
  
  
  6.         temp = null;  
    7.   
  
  
  7.     for (let i = 0; i < keys.length; i++) {  
    8.   
  
  
  8.         key = keys[i];      
    9.   
  
  
  9.         temp = obj[key];  
    10.   
  
  
  10.         // 如果字段的值也是一个对象则递归操作  
    11.   
  
  
  11.         if (temp && typeof temp === 'object') {  
    12.   
  
  
  12.             result[key] = deepCopy(temp);  
    13.   
  
  
  13.         } else {  
    14.   
  
  
  14.         // 否则直接赋值给新对象  
    15.   
  
  
  15.             result[key] = temp;  
    16.   
  
  
  16.         }  
    17.   
  
  
  17.     }  
    18.   
  
  
  18.     return result;  
    19.   
  
  
  19. }  
    20.   
  
  
  20. var obj1 = {  
    21.   
  
  
  21.     x: {  
    22.   
  
  
  22.         m: 1  
    23.   
  
  
  23.     },  
    24.   
  
  
  24.     y: undefined,  
    25.   
  
  
  25.     z: function add(z1, z2) {  
    26.   
  
  
  26.         return z1 + z2  
    27.   
  
  
  27.     },  
    28.   
  
  
  28.     a: Symbol("foo")  
    29.   
  
  
  29. };  
    30.   
  
  
  30. var obj2 = deepCopy(obj1);  
    31.   
  
  
  31. obj2.x.m = 2;  
    32.   
  
  
  32. console.log(obj1); //{x: {m: 1}, y: undefined, z: ƒ, a: Symbol(foo)}  
    33.   
  
  
  33. console.log(obj2); //{x: {m: 2}, y: undefined, z: ƒ, a: Symbol(foo)} 
    34.

可以看到，递归***的解决了前面遗留的所有问题，我们也可以用第三方库：jquery的$.extend和lodash的_.cloneDeep来解决深拷贝。上面虽然是用Object验证，但对于Array也同样适用，因为Array也是特殊的Object。

到这里，深拷贝问题基本可以告一段落了。但是，还有一个非常特殊的场景：

循环引用拷贝

 
 
 
    
  
  
  
  1. var obj1 = {  
    2.   
  
  
  2.     x: 1,   
    3.   
  
  
  3.     y: 2  
    4.   
  
  
  4. };  
    5.   
  
  
  5. obj1.z = obj1;  
    6.   
  
  
  6. var obj2 = deepCopy(obj1); 
    7.

此时如果调用刚才的deepCopy函数的话，会陷入一个循环的递归过程，从而导致爆栈。jquery的$.extend也没有解决。解决这个问题也非常简单，只需要判断一个对象的字段是否引用了这个对象或这个对象的任意父级即可，修改一下代码：

 
 
 
    
  
  
  
  1. function deepCopy(obj, parent = null) {  
    2.   
  
  
  2.     // 创建一个新对象  
    3.   
  
  
  3.     let result = {};  
    4.   
  
  
  4.     let keys = Object.keys(obj),  
    5.   
  
  
  5.         key = null,  
    6.   
  
  
  6.         temp= null,  
    7.   
  
  
  7.         _parent = parent;  
    8.   
  
  
  8.     // 该字段有父级则需要追溯该字段的父级  
    9.   
  
  
  9.     while (_parent) {  
    10.   
  
  
  10.         // 如果该字段引用了它的父级则为循环引用  
    11.   
  
  
  11.         if (_parent.originalParent === obj) {  
    12.   
  
  
  12.             // 循环引用直接返回同级的新对象  
    13.   
  
  
  13.             return _parent.currentParent;  
    14.   
  
  
  14.         }  
    15.   
  
  
  15.         _parent = _parent.parent;  
    16.   
  
  
  16.     }  
    17.   
  
  
  17.     for (let i = 0; i < keys.length; i++) {  
    18.   
  
  
  18.         key = keys[i];  
    19.   
  
  
  19.         temp= obj[key];  
    20.   
  
  
  20.         // 如果字段的值也是一个对象  
    21.   
  
  
  21.         if (temp && typeof temp=== 'object') {  
    22.   
  
  
  22.             // 递归执行深拷贝 将同级的待拷贝对象与新对象传递给 parent 方便追溯循环引用  
    23.   
  
  
  23.             result[key] = DeepCopy(temp, {  
    24.   
  
  
  24.                 originalParent: obj,  
    25.   
  
  
  25.                 currentParent: result,  
    26.   
  
  
  26.                 parent: parent  
    27.   
  
  
  27.             });  
    28.   
  
  
  28.         } else { 
    29.   
  
  
  29.             result[key] = temp;  
    30.   
  
  
  30.         }  
    31.   
  
  
  31.     }  
    32.   
  
  
  32.     return result;  
    33.   
  
  
  33. }  
    34.   
  
  
  34. var obj1 = {  
    35.   
  
  
  35.     x: 1,   
    36.   
  
  
  36.     y: 2  
    37.   
  
  
  37. };  
    38.   
  
  
  38. obj1.z = obj1;  
    39.   
  
  
  39. var obj2 = deepCopy(obj1);  
    40.   
  
  
  40. console.log(obj1); //太长了去浏览器试一下吧～   
    41.   
  
  
  41. console.log(obj2); //太长了去浏览器试一下吧～  
    42.

至此，已完成一个支持循环引用的深拷贝函数。当然，也可以使用lodash的_.cloneDeep噢～。

本文标题：低门槛彻底理解JavaScript中的深拷贝和浅拷贝
路径分享：http://www.gawzjz.com/qtweb2/news12/19862.html

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

广告

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

猜你还喜欢下面的内容

营销型网站建设知识

分类信息网

边坡柔性防护网　　 　关键词优化排名　　 　香港空间　　 　网站解决方案　　 　成都h5建站开发　　 　成都网站设计　　 　网站建设　　 　成都商城网站建设　　 　手机网站建设　　 　网站空间　　 　成都展柜厂　　 　木包装箱　　 　成都400电话申请　　 　成都小程序开发　　 　阿坝网站建设　　 　成都二枢电信服务器托管　　 　微信小程序开发　　 　成都商城网站建设　　 　成都营销网站建设　　 　成都微商城