淺拷貝與深拷貝的區(qū)別

一谎懦、數(shù)據(jù)類型

數(shù)據(jù)分為基本數(shù)據(jù)類型(String, Number, Boolean, Null, Undefined淤堵，Symbol)和對象數(shù)據(jù)類型碌更。

基本數(shù)據(jù)類型的特點：直接存儲在棧(stack)中的數(shù)據(jù)劳吠。
引用數(shù)據(jù)類型的特點：存儲的是該對象在棧中引用，真實的數(shù)據(jù)存放在堆內(nèi)存里十减。

引用數(shù)據(jù)類型在棧中存儲了指針，該指針指向堆中該實體的起始地址愤估。當解釋器尋找引用值時帮辟，會首先檢索其在棧中的地址，取得地址后從堆中獲得實體玩焰。

二由驹、淺拷貝與深拷貝

深拷貝和淺拷貝是只針對Object和Array這樣的引用數(shù)據(jù)類型的。
深拷貝和淺拷貝的示意圖大致如下：

淺拷貝只復制指向某個對象的指針震捣，而不復制對象本身荔棉，新舊對象還是共享同一塊內(nèi)存。但深拷貝會另外創(chuàng)造一個一模一樣的對象蒿赢，新對象跟原對象不共享內(nèi)存润樱，修改新對象不會改到原對象。

三羡棵、賦值和淺拷貝的區(qū)別

當我們把一個對象賦值給一個新的變量時壹若，賦的其實是該對象的在棧中的地址，而不是堆中的數(shù)據(jù)皂冰。也就是兩個對象指向的是同一個存儲空間店展，無論哪個對象發(fā)生改變，其實都是改變的存儲空間的內(nèi)容秃流，因此赂蕴，兩個對象是聯(lián)動的。
淺拷貝是按位拷貝對象舶胀，它會創(chuàng)建一個新對象概说，這個對象有著原始對象屬性值的一份精確拷貝碧注。如果屬性是基本類型，拷貝的就是基本類型的值糖赔；如果屬性是內(nèi)存地址（引用類型）萍丐，拷貝的就是內(nèi)存地址，因此如果其中一個對象改變了這個地址放典，就會影響到另一個對象逝变。即默認拷貝構(gòu)造函數(shù)只是對對象進行淺拷貝復制(逐個成員依次拷貝)，即只復制對象空間而不復制資源奋构。

我們先來看兩個例子壳影，對比賦值與淺拷貝會對原對象帶來哪些改變？

      // 對象賦值
        var obj1={
            'name':'zhangsan',
            'age':'18',
            'language':[1,[2,3],[4,5]],
        };
        var obj2=obj1;
        obj2.name="lisi";
        obj2.language[1]=["二","三"];
        console.log('obj1',obj1);
        console.log('obj2',obj2);

      // 淺拷貝
        var obj1={
            'name':'zhangsan',
            'age':'18',
            'language':[1,[2,3],[4,5]],
        };
        var obj3=shallowCopy(obj1);
        obj3.name="lisi";
        obj3.language[1]=["二","三"];
        function shallowCopy(src){
            var dst={};
            for (var prop in src) {
                if (src.hasOwnProperty(prop)) {//判斷一個對象自身(不包括原型鏈)是否具有指定名稱的屬性声怔。如果有态贤，返回true，否則返回false醋火。
                    dst[prop]=src[prop];
                }
            }
            return dst;
        }
        console.log('obj1',obj1);
        console.log('obj3',obj3);

上面例子中悠汽，obj1是原始數(shù)據(jù)，obj2是賦值操作得到芥驳，而obj3淺拷貝得到柿冲。我們可以很清晰看到對原始數(shù)據(jù)的影響，具體請看下表：

四兆旬、淺拷貝的實現(xiàn)方式

1.Object.assign()

Object.assign() 方法可以把任意多個的源對象自身的可枚舉屬性拷貝給目標對象假抄，然后返回目標對象。但是 Object.assign()進行的是淺拷貝丽猬，拷貝的是對象的屬性的引用宿饱，而不是對象本身。

        var obj={a:{a:"kobe",b:39}};
        var initalObj=Object.assign({},obj);
        initalObj.a.a="wade";
        console.log(obj.a.a);//wade

注意：當object只有一層的時候脚祟，是深拷貝谬以。

        let obj={
            username:'kobe'
        };
        let obj2=Object.assign({},obj);
        obj2.username="wade";
        console.log(obj);//{username:"kobe"}

2.Array.prototype.concat()

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

修改新對象會改到原對象:

3.Array.prototype.slice()

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

同樣修改新對象會改到原對象：

Array的slice和concat方法不修改原數(shù)組，只會返回一個淺復制了原數(shù)組中的元素的一個新數(shù)組由桌。

原數(shù)組的元素會按照下述規(guī)則拷貝：

如果該元素是個對象引用(不是實際的對象)为黎，slice 會拷貝這個對象引用到新的數(shù)組里。兩個對象引用都引用了同一個對象行您。如果被引用的對象發(fā)生改變铭乾，則新的和原來的數(shù)組中的這個元素也會發(fā)生改變。
對于字符串娃循、數(shù)字及布爾值來說（不是 String炕檩、Number 或者 Boolean 對象），slice 會拷貝這些值到新的數(shù)組里捌斧。在別的數(shù)組里修改這些字符串或數(shù)字或是布爾值笛质，將不會影響另一個數(shù)組吹泡。

可能這段話晦澀難懂，我們舉個例子经瓷，將上面的例子小作修改：??

        let arr=[1,3,{
            username:'kobe'
        }];
        let arr3=arr.slice();
        arr3[1]=2;
        console.log(arr,arr3);

五、深拷貝的實現(xiàn)方式

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

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

原理：用JSON.stringify將對象轉(zhuǎn)成JSON字符串洞难，再用JSON.parse()把字符串解析成對象舆吮，一去一來，新的對象產(chǎn)生了队贱，而且對象會開辟新的棧色冀，實現(xiàn)深拷貝。

這種方法雖然可以實現(xiàn)數(shù)組或?qū)ο笊羁截?但不能處理函數(shù)柱嫌。

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

這是因為JSON.stringify() 方法是將一個JavaScript值(對象或者數(shù)組)轉(zhuǎn)換為一個 JSON字符串锋恬，不能接受函數(shù)。

2.手寫遞歸方法

        // 定義檢測數(shù)據(jù)類型的功能函數(shù)
        function checkedType(target){
            return Object.prototype.toString.call(target).slice(8,-1)
        }
        // 實現(xiàn)深度克隆---對象/數(shù)組
        function clone(target){
            // 判斷拷貝的數(shù)據(jù)類型
            // 初始化變量result 成為最終克隆的數(shù)據(jù)
            let result,targetType=checkedType(target)
            if(targetType==='object'){
                result={}
            }else if(targetType==='Array'){
                result=[]
            }else{
                return target
            }
            // 遍歷目標數(shù)據(jù)
            for(let i in target){
                // 獲取遍歷數(shù)據(jù)結(jié)構(gòu)的每一項值
                let value=target[i]
                // 判斷目標結(jié)構(gòu)里的每一值是否存在對象/數(shù)組
                if(checkedType(value)==='Object'||checkedType(value)==='Array'){//對象/數(shù)組里嵌套了對象/數(shù)組
                    // 繼續(xù)遍歷獲取到value值
                    result[i]=clone(value)
                }else{//獲取到value值是基本的數(shù)據(jù)類型或者是函數(shù)
                    result[i]=value;
                }
            }
            return result
        }

原理：遍歷對象编丘、數(shù)組直到里邊都是基本數(shù)據(jù)類型与学，然后再去復制，就是深度拷貝嘉抓。

3.函數(shù)庫lodash

該函數(shù)庫也有提供_.cloneDeep用來做 Deep Copy索守。

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

作者：coding小姐姐
原文鏈接：https://segmentfault.com/a/1190000018874254