Javascript浅拷贝和深拷贝

面试的时候，经常会被问到js的浅拷贝和深拷贝问题，很多时候能够想清楚是怎么回事，但是实在描述不出来，可能还是自己比较差，今天看了好多关于深浅拷贝的博客，其中 有一篇很全面，这里把网页地址贴出来，

关于JavaScript的浅拷贝和深拷贝

我自己也通过学习做了一些总结，emmmmm，不知道要怎么说了，开始吧！

1.关于浅拷贝和深拷贝，首先要了解一下栈(stack)和堆(heap)

栈(stack)和堆(heap)

空间分配：

栈：为操作系统自动分配的内存空间，他由系统自动释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈，先进后出。

堆：动态分配的内存，大小不定也不会自动释放，队列优先,先进先出。

缓存方式：

栈使用的是一级缓存， 他们通常都是被调用时处于存储空间中，调用完毕立即释放。

堆则是存放在二级缓存中，生命周期由虚拟机的垃圾回收算法来决定（并不是一旦成为孤儿对象就能被回收）。所以调用这些对象的速度要相对来得低一些。

2.接下来，我们再来说一下 基本类型和引用类型

基本类型和引用类型

基本类型：存放在栈内存中的简单数据段，数据大小确定，内存空间大小可以分配。

基本类型有：Number，String，Boolean，Null，Undefined；它们是直接按值存放的，所以可以直接访问；

引用类型：存放在堆内存中的对象，变量实际保存的是一个指针，这个指针指向另一个位置，每个空间大小都不一样，要根据情况进行特定的分配。

引用类型有：对象（object），数组（array），函数（function），当我们要访问引用类型的值时，首先要先从栈中读取内存地址， 然后再通过地址找到堆中的值。

3.传值与传址

test：

        <script>
            var a = [1,2,3,4,5];
            var b = a;
            var c = a[0];
            console.log(b);
            console.log(c);
            //改变数值
            b[4]=8;
            c=7;
            console.log(a);
            console.log(b);
            console.log(c);
        </script>

传值与传址的结果.png

如图所示，改变变量b中的数据时，a中的数据也发生了变化，而改变c的值，a没有发生任何变化，只有c的值发生了改变。
原因很简单，因为a为数组，属于引用类型，所以它赋值给b传递的只是存储在栈中的地址（相当于创建了一个不同名的指针指向a指向的堆内存空间），而c只是从a堆内存中获取的一个数据值，保存在栈中，（相当于重新开辟了一块内存空间）所以修改b的值时，会根据地址回到a堆中进行修改，而c直接在栈中修改，并且不指向a堆内存中。
用一张图总结一下：

堆和栈.jpg

4.要正式开始说浅拷贝和深拷贝了，浅拷贝和深拷贝主要是对于引用类型

浅拷贝和深拷贝.png

浅拷贝只复制指向某个对象的指针，但是还是共用同一块内存空间，修改新对象会修改旧对象，而深拷贝会创造另一个一模一样的对象，新对象和旧对象不共享内存，修改新对象不会改到旧对象。

（一）浅拷贝

在定义一个对象数组时，变量存放的往往只是一个地址，当我们使用对象拷贝时，如果属性是对象或者数组时，这是我们传递的也只是一个地址，因此对象在访问该属性时，会根据地址回溯到父对象的堆内存中，即父子对象发生了关联，两者的属性值会指向同一块内存空间。

（1）
test1：

        <script>
            var a ={key1:"111111"};
            function Copy(p){
                var c = {};
                for(var i in p){
                    c[i]=p[i];
                }
                console.log(c);//object{key1: "111111", key2: Array(2)}
                return c;
            }
            a.key2=["喵喵","喵"];
            var b = Copy(a);
            b.key3="333333";
            console.log(b);//object{key1: "111111", key2: Array(2), key3: "333333"}
            console.log(a);//object{key1: "111111", key2: Array(2)}
            b.key2.push("喵喵喵");
            console.log(b);//object{key1: "111111", key2: Array(3), key3: "333333"}
            console.log(a);//object{key1: "111111", key2: Array(3)}
        </script>

a对象中的key1的属性是字符串，key2的属性是数组，将a拷贝到b，key1,key2的值均可顺利拷贝，给b新增一个字符串类型的属性key3时，b能正常修改，而a中无定义;当给b对象的key2属性数组增加一个数值时，a对象的key2属性的值也发生改变；

（2）object.assign();

es6新函数，object.assign()可以把任意多个的源对象的可枚举属性拷贝给目标对象，然后返回目标对象，相当于对象合并，但是object.assign()进行的只是浅拷贝，拷贝的是对象的属性的引用，而不是对象本身。

object.assign(target,...source);
target：目标对象；
source：任意多个源对象；
返回值：目标对象

test2：

<script>
            "use strict";
            var obj = {a:1};
            var copy =Object.assign({},obj);
            console.log(copy);//{a:1};
            var obj = { a: {a: "hello", b: 21} };
            var initalObj = Object.assign({}, obj);
            initalObj.a.a = "changed";
            console.log(obj.a.a); // "changed"
        </script>

（二）深拷贝

要完全复制又不能修改到原对象，这时候就要用 Deep Copy，创造另一个一模一样的对象，新对象和旧对象不共享内存，修改新对象不会改到旧对象。

（1）Object.assign()可以处理一层对象的深拷贝；

<script>
            var obj1 ={a:10,b:20,c:30};
            var obj2 =Object.assign({},obj1);
            obj2.b = 50;
            console.log(obj1);//{a:10,b:20,c:30}
            console.log(obj2);//{a:10,b:50,c:30}
</script>

Object.assign({},source);先建立一个kogduixiang空对象{}，接着把obj1中所有的属性复制过去，所以obj2会长得跟obj1一样，这时候再修改obj2.b也不会影响obj1。

（2）递归方法进行深拷贝；

test:

        <script>
            function deepCopy(initalobj,finalobj){
                var obj = finalobj||{};
                for(var i in initalobj){
                    if(typeof initalobj[i] ==="object"){
                        obj[i]=(initalobj[i].constructor===Array)?[]:{};
                        deepCopy(initalobj[i],obj[i]);
                    }
                    else{
                        obj[i]=initalobj[i];
                    }
                }
                return obj;
            }
            
            var obj ={a:{a:"hello",b:10}};
            var str =deepCopy(obj,str);
            console.log(str);//{a:{a: "changed", b: 10}}
            str.a.a="changed";
            console.log(str);//{a:{a: "changed", b: 10}}
            console.log(obj);//{a:{a:"hello",b:10}}
        </script>

用递归函数进行深拷贝，首先函数deepCopy传入两个参数为原型对象和拷贝对象，在函数内部var一个变量obj将拷贝对象赋值给它，如果没有拷贝对象，则将一个空对象赋值给obj，然后对原始对象进行for...in遍历，判断每个属性的值是否嵌套，用constructor判断他是否为数组，然后再次调用函数，一直到它为一个单层对象时，赋值；接下来，改变拷贝对象的属性值，则不会影响原型对象。如例子所示，改变str的值，obj的值不会发生改变。

（3）转换成Json再转换回来（JSON.stringify()和JSON.parse()）

JSON.stringify() 方法是将一个JavaScript值(对象或者数组)转换为一个 JSON字符串,转化成字符串后就可以进行拷贝，则为值拷贝，会在栈内存空间中重新划分一块内存空间。
test：

        <script>
            var initalobj = {a:{b:3,c:5}};
            var finalobj =JSON.parse(JSON.stringify(initalobj));
            finalobj.a.b=8;
            console.log(initalobj);//{a:{b:3,c:5}}
            console.log(finalobj);//{a:{b:8,c:5}}
        </script>

（4）使用Object.create()方法

直接使用var newObj = Object.create(oldObj)，可以达到深拷贝的效果。
test：

         <script>
            function deepCopy(initalobj,finalobj){
                var obj = finalobj||{};
                for(var i in initalobj){
                    var prop = initalobj[i]; // 避免相互引用对象导致死循环，如initalObj.a = initalObj的情况
                    if(prop===obj){
                        continue;
                    }
                    if(typeof prop === "object"){
                        obj[i]=(prop.constructor===Array)?[]:Object.create(prop);
                        alert("111");
                    }
                    else{
                        obj[i]=prop;
                    }
                }
                return obj; 
            }
            var obj={a:{b:3,c:5}};
            var newobj={};
            deepCopy(obj,newobj);
            console.log(obj);
            newobj.a.b=9;
            console.log(obj);
            console.log(newobj);
        </script>

(5)JQuery方法；$.extend();

        <script>
            var obj1 = {
                a: 1,
                b: { f: { g: 1 } },
                c: [1, 2, 3]
            };
            var obj2 = $.extend(true, {}, obj1);
            obj2.b.f.g=10;
            console.log(obj1);
            console.log(obj2);
            console.log(obj1.b.f === obj2.b.f);
        </script>

$.extend(true, {}, obj1)

(6)lodash

一个很热门的函数库lodash，也有提供_.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

最后这个不太了解，知识面太窄，有兴趣的可以了解一下，当然我也会自己学习一下。
关于浅拷贝和深拷贝，就先写在这里了，下次见。