日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關(guān)咨詢
選擇下列產(chǎn)品馬上在線溝通
服務(wù)時(shí)間：8:30-17:00
你可能遇到了下面的問題
關(guān)閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
一文讀懂Javascript深拷貝與淺拷貝

 前言

在 javascript 中有不同的方法來復(fù)制對象，如果你還不熟悉這門語言的話，復(fù)制對象時(shí)就會(huì)很容易掉進(jìn)陷阱里，那么我們怎樣才能正確地復(fù)制一個(gè)對象呢?

創(chuàng)新互聯(lián)公司自2013年起，是專業(yè)互聯(lián)網(wǎng)技術(shù)服務(wù)公司，擁有項(xiàng)目網(wǎng)站建設(shè)、成都網(wǎng)站制作網(wǎng)站策劃，項(xiàng)目實(shí)施與項(xiàng)目整合能力。我們以讓每一個(gè)夢想脫穎而出為使命，1280元子長做網(wǎng)站,已為上家服務(wù),為子長各地企業(yè)和個(gè)人服務(wù),聯(lián)系電話:028-86922220

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

  • 什么是深/淺拷貝，他們跟賦值有何區(qū)別?
  • 深/淺拷貝的實(shí)現(xiàn)方式有幾種?

淺拷貝與深拷貝

  • 淺拷貝是創(chuàng)建一個(gè)新對象，這個(gè)對象有著原始對象屬性值的一份精確拷貝。如果屬性是基本類型，拷貝的就是基本類型的值，如果屬性是引用類型，拷貝的就是內(nèi)存地址 ，所以如果其中一個(gè)對象改變了這個(gè)地址，就會(huì)影響到另一個(gè)對象。
  • 深拷貝是將一個(gè)對象從內(nèi)存中完整的拷貝一份出來,從堆內(nèi)存中開辟一個(gè)新的區(qū)域存放新對象,且修改新對象不會(huì)影響原對象。

 

 
 
 
 
    
  
  
  
  
  1. var a1 = {b: {c: {}}; 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. var a2 = shallowClone(a1); // 淺拷貝方法 
    4. 
  
  
  
  
  4. a2.b.c === a1.b.c // true 新舊對象還是共享同一塊內(nèi)存 
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6. var a3 = deepClone(a3); // 深拷貝方法 
    7. 
  
  
  
  
  7. a3.b.c === a1.b.c // false 新對象跟原對象不共享內(nèi)存 
    8.

借助ConardLi大佬以下兩張圖片，幫我們更好的理解兩者的含義：

 

 

總而言之，淺拷貝只復(fù)制指向某個(gè)對象的指針，而不復(fù)制對象本身，新舊對象還是共享同一塊內(nèi)存。但深拷貝會(huì)另外創(chuàng)造一個(gè)一模一樣的對象，新對象跟原對象不共享內(nèi)存，修改新對象不會(huì)改到原對象。

賦值和深/淺拷貝的區(qū)別

這三者的區(qū)別如下，不過比較的前提都是針對引用類型：

  • 當(dāng)我們把一個(gè)對象賦值給一個(gè)新的變量時(shí)，賦的其實(shí)是該對象的在棧中的地址，而不是堆中的數(shù)據(jù)。也就是兩個(gè)對象指向的是同一個(gè)存儲(chǔ)空間，無論哪個(gè)對象發(fā)生改變，其實(shí)都是改變的存儲(chǔ)空間的內(nèi)容，因此，兩個(gè)對象是聯(lián)動(dòng)的。
  • 淺拷貝：重新在堆中創(chuàng)建內(nèi)存，拷貝前后對象的基本數(shù)據(jù)類型互不影響，但拷貝前后對象的引用類型因共享同一塊內(nèi)存，會(huì)相互影響。
  • 深拷貝：從堆內(nèi)存中開辟一個(gè)新的區(qū)域存放新對象，對對象中的子對象進(jìn)行遞歸拷貝,拷貝前后的兩個(gè)對象互不影響。

我們先來看下面的例子，對比賦值與深/淺拷貝得到的對象修改后對原始對象的影響：

 
 
 
 
    
  
  
  
  
  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] ; // 新舊對象還是共享同一塊內(nèi)存 
    9. 
  
  
  
  
  9. // 這是個(gè)淺拷貝的方法 
    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] ; // 新對象跟原對象不共享內(nèi)存 
    9. 
  
  
  
  
  9. // 這是個(gè)深拷貝的方法 
    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.         // 實(shí)現(xiàn)一個(gè)遞歸拷貝 
    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深拷貝得到的對象，通過下面的表格，我們可以很清晰看到他們對原始數(shù)據(jù)的影響：

 

淺拷貝的實(shí)現(xiàn)方式

1.Object.assign()

Object.assign() 方法可以把任意多個(gè)的源對象自身的可枚舉屬性拷貝給目標(biāo)對象，然后返回目標(biāo)對象。

 
 
 
 
    
  
  
  
  
  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.函數(shù)庫lodash的_.clone方法

該函數(shù)庫也有提供_.clone用來做 Shallow Copy,后面我們會(huì)再介紹利用這個(gè)庫實(shí)現(xiàn)深拷貝。

 
 
 
 
    
  
  
  
  
  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.展開運(yùn)算符...

展開運(yùn)算符是一個(gè) es6 / es2015特性，它提供了一種非常方便的方式來執(zhí)行淺拷貝，這與 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.

深拷貝的實(shí)現(xiàn)方式

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將對象轉(zhuǎn)成JSON字符串，再用JSON.parse把字符串解析成對象，一去一來，新的對象產(chǎn)生了，而且對象會(huì)開辟新的棧，實(shí)現(xiàn)深拷貝。

這種方法雖然可以實(shí)現(xiàn)數(shù)組或?qū)ο笊羁截?但不能處理函數(shù)和正則，因?yàn)檫@兩者基于JSON.stringify和JSON.parse處理后，得到的正則就不再是正則(變?yōu)榭諏ο?，得到的函數(shù)就不再是函數(shù)(變?yōu)閚ull)了。

比如下面的例子：

 
 
 
 
    
  
  
  
  
  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.函數(shù)庫lodash的_.cloneDeep方法

該函數(shù)庫也有提供_.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 有提供一個(gè)$.extend可以用來做 Deep Copy

 
 
 
 
    
  
  
  
  
  1. $.extend(deepCopy, target, object1, [objectN])//第一個(gè)參數(shù)為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.手寫遞歸方法

遞歸方法實(shí)現(xiàn)深度克隆原理：遍歷對象、數(shù)組直到里邊都是基本數(shù)據(jù)類型，然后再去復(fù)制，就是深度拷貝。

有種特殊情況需注意就是對象存在循環(huán)引用的情況，即對象的屬性直接的引用了自身的情況，解決循環(huán)引用問題，我們可以額外開辟一個(gè)存儲(chǔ)空間，來存儲(chǔ)當(dāng)前對象和拷貝對象的對應(yīng)關(guān)系，當(dāng)需要拷貝當(dāng)前對象時(shí)，先去存儲(chǔ)空間中找，有沒有拷貝過這個(gè)對象，如果有的話直接返回，如果沒有的話繼續(xù)拷貝，這樣就巧妙化解的循環(huán)引用的問題。關(guān)于這塊如有疑惑，請仔細(xì)閱讀ConardLi大佬如何寫出一個(gè)驚艷面試官的深拷貝?這篇文章。

 
 
 
 
    
  
  
  
  
  1. function deepClone(obj, hash = new WeakMap()) { 
    2. 
  
  
  
  
  2.   if (obj === null) return obj;  
    3. 
  
  
  
  
  3.   // 如果是null或者undefined我就不進(jìn)行拷貝操作 
    4. 
  
  
  
  
  4.   if (obj instanceof Date) return new Date(obj); 
    5. 
  
  
  
  
  5.   if (obj instanceof RegExp) return new RegExp(obj); 
    6. 
  
  
  
  
  6.   // 可能是對象或者普通的值  如果是函數(shù)的話是不需要深拷貝 
    7. 
  
  
  
  
  7.   if (typeof obj !== "object") return obj; 
    8. 
  
  
  
  
  8.   // 是對象的話就要進(jìn)行深拷貝 
    9. 
  
  
  
  
  9.   if (hash.get(obj)) return hash.get(obj); 
    10. 
  
  
  
  
  10.   let cloneObj = new obj.constructor(); 
    11. 
  
  
  
  
  11.   // 找到的是所屬類原型上的constructor,而原型上的 constructor指向的是當(dāng)前類本身 
    12. 
  
  
  
  
  12.   hash.set(obj, cloneObj); 
    13. 
  
  
  
  
  13.   for (let key in obj) { 
    14. 
  
  
  
  
  14.     if (obj.hasOwnProperty(key)) { 
    15. 
  
  
  
  
  15.       // 實(shí)現(xiàn)一個(gè)遞歸拷貝 
    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; // 對象存在循環(huán)引用的情況 
    23. 
  
  
  
  
  23. let d = deepClone(obj); 
    24. 
  
  
  
  
  24. obj.address.x = 200; 
    25. 
  
  
  
  
  25. console.log(d); 
    26.

新聞標(biāo)題：一文讀懂Javascript深拷貝與淺拷貝
URL地址：http://www.5511xx.com/article/copciid.html