1. 浅拷贝概念

什么叫作浅拷贝：

针对简单的数据类型，拷贝值；

针对复杂的数据类型，单独开辟新的内存空间，在栈里面会有地址指向这个空间，拷贝地址

改变旧的对象的复杂数据类型的值，新的对象的对应值也会改变，借用一个博主的话，拷贝以后复杂数据类型不能够自食其力，旧叫浅拷贝。因为传递地址，也叫引用传递。

浅拷贝的例子1：for? in? 进行浅拷贝

        var obj = {
            name: 'a',
            msg: {
                age: 18,
            }
        }
        var o = {};
        for (var k in obj) {
            o[k] = obj[k];
        }
        console.log(o); // age是19 name还是a
        obj.name = 'b';
        obj.msg.age = 19;
        console.log(obj); // age是19 name是b
        console.log(o); // age是19 name是a

修改了obj的msg对象的age值，o对象的也发生变化

修改了obj的name值，o对象的没有发生变化

浅拷贝的例子2：定义数组进行浅拷贝

        let a = [1, 2, 3, 4, 5];
        let b = a;
        a[0] = 3;
        console.log(a); // [3, 2, 3, 4, 5]
        console.log(b); // [3, 2, 3, 4, 5]
        console.log(a === b); // true

?总结：

1. a数组赋值给了b数组
2. 紧接着修改a数组的一个值，b的数组也相应的变化，这个就是浅拷贝，

浅拷贝的例子3：利用Object.assign()方法进行拷贝

        var oldObj = {
            name: 'good',
            msg: {
                age: 18
            }
        }
        var newObj = {};
        Object.assign(newObj, oldObj);
        console.log(newObj); // 能够拷贝成功
        oldObj.msg.age = 19;
        console.log(oldObj); // age = 19
        console.log(newObj); // age = 19 表明浅拷贝成功

修改newObj的msg对象的age值，oldObj的age值也发生变化，证明是浅拷贝

2. 深拷贝

概念：

newObj拷贝了oldObj的值，拷贝之后，修改newObj的复杂数据类型值，oldObj的复杂数据值不会改变。能够自食其力

????????逻辑

????????1.?先判断对象里的元素是数组吗？

????????1.1?如果是，新对象里面的对应属性的属性值，让其创建一个新数组，递归

????????1.2?如果不是数组，再判断是不是对象，如果是，新对象对应的属性值，让其创建一个新对象，递归

????????2.?递归点，?oldObj的属性值赋值给newObj对应的属性，newObj[k]?=?item;

        var furn = {
            size: '10',
            msg: {
                size: '100',
                msg: {
                    size: '1000'
                }
            }
        };
        function deepCopy(newObj, oldObj) {
            for (var k in oldObj) {
                var item = oldObj[k];
                if (item instanceof Array) {
                    newObj[k] = [];
                    deepCopy(newObj[k], item);
                } else if (k instanceof Object) {
                    newObj[k] = {};
                    deepCopy(newObj[k], item);
                } else {
                    newObj[k] = item;
                }
            }
            return newObj;
        }
        console.log(deepCopy(furn));

最终输出的结果，是拷贝之后的元素