深浅拷贝问题拷贝：在赋值的时候即使目标是引用类型，也在内存中新开辟一块空间，将原始数据原封不动的拷贝过去，从而修改A的时

---针对引用类型

传统复制

将两个变量都指向了同一块内存空间，A变动B也会随之变动；

let arr1 = [
    "a",
    "b",
    {
        name:"cc"
    }
]
let arr2 = arr1
arr1.push("d");
console.log(arr1);  //[ 'a', 'b', { name: 'cc' }, 'd' ]
console.log(arr2);  //[ 'a', 'b', { name: 'cc' }, 'd' ]

拷贝：在赋值的时候即使目标是引用类型，也在内存中新开辟一块空间，将原始数据原封不动的拷贝过去，从而修改A的时候不会影响到B。

浅拷贝

浅层次地拷贝，A中的变动不会影响到B，但是如果A中存在引用类型，则二者存储的都是引用类型的指针地址，如果变动，则会导致B也随之变动，所以，这是浅拷贝。（创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值，如果属性是引用类型，拷贝的就是内存地址，所以如果其中一个对象改变了这个地址，就会影响到另一个对象。）
```
function shallowCopy(obj1, obj2){
    for(var key in obj1){
        obj2[key] = obj1[key];
    }
}
let obj1 = {
    a:"a",
    b:"b",
    c:{
        name:"cc"
    }
}
let obj2 = {}
shallowCopy(obj1,obj2)
obj2.d = "d"; //obj2的变动对obj1没有影响
obj2.c.name="hhh"; //obj2的变动对obj1有了影响
console.log(obj1) //{ a: 'a', b: 'b', c: { name: 'hhh' } }
console.log(obj2) //{ a: 'a', b: 'b', c: { name: 'hhh' }, d: 'd' }
```

方法

数组

Array.concat()

let arr = ['a', 'b', 'c',{name:'dd'}];
let newArr = arr.concat();
newArr.push("e");
newArr[3].name = "hhh"
console.log(arr); //[ 'a', 'b', 'c', { name: 'hhh' } ]
console.log(newArr); //[ 'a', 'b', 'c', { name: 'hhh' }, 'e' ]

Array.slice()

let arr = ["a", "b", "c"];
let newArr = arr.slice();
newArr.push("d");
console.log(arr); //[ 'a', 'b', 'c' ]
console.log(newArr); //[ 'a', 'b', 'c', 'd' ]

对象

Object.assign() 可以把任意多个源对象自身的可枚举属性拷贝给目标对象，然后返回目标对象

let arr = {
    a:"aa",
    b:"bb",
    c:{name:"cc"}
};
let newArr = Object.assign({}, arr)
newArr.d = "dd";
newArr.c.name = "hhh";
console.log(arr); //{ a: 'aa', b: 'bb', c: { name: 'hhh' } }
console.log(newArr); //{ a: 'aa', b: 'bb', c: { name: 'hhh' }, d: 'dd' }

ES6扩展符{...Object}

let arr = {
    a:"aa",
    b:"bb",
    c:{name:"cc"}
};
let newArr = {...arr}
newArr.d = "dd";
newArr.c.name = "hhh";
console.log(arr); //{ a: 'aa', b: 'bb', c: { name: 'hhh' } }
console.log(newArr); //{ a: 'aa', b: 'bb', c: { name: 'hhh' }, d: 'dd' }

封装浅拷贝（遍历需要克隆的对象，然后把需要克隆对象的属性和属性值都依次放在一个新的对象中，返回。）

let shallowCopy = function(obj){
    if(typeof obj !== "object") return;
    let newObj = obj instanceof Array? []:{};
    for(let key in obj){
        if(obj.hasOwnProperty(key)){
            newObj[key] = obj[key];
        }
    }
    return newObj;
}

深拷贝

深层次地拷贝，A中的无论什么变动都不会影响到B。深拷贝将数据完全复制到新开辟的内存空间中。（将一个对象从内存中完整的拷贝一份出来，从堆内存中开辟一个新的区域存放新对象，且修改新对象不会影响原对象。）

function deepCopy(obj){
    let newObj = Array.isArray(obj)? []:{};
    if(obj && typeof obj === 'object'){
        for(key in obj){
            if(obj[key] && typeof obj[key] === "object"){
                newObj[key] = deepCopy(obj[key])
            }else{
                newObj[key] = obj[key]
            }
        }
    }
    return newObj;
}

let obj1 = {
    a:"a",
    b:"b",
    c:{
        name:"cc"
    }
}
let obj2 = deepCopy(obj1);
obj2.c.name = "hhh";
obj2.d = "dd";
console.log(obj1); //{ a: 'a', b: 'b', c: { name: 'cc' } }
console.log(obj2); //{ a: 'a', b: 'b', c: { name: 'hhh' }, d: 'dd' }

方法

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

let arr = {
    a:"a",
    b:"b",
    c:{
        name:"cc"
    }
};
let newArr = JSON.parse(JSON.stringify(arr));
newArr.c.name = "hhh";
console.log(arr); //{ a: 'a', b: 'b', c: { name: 'cc' } }
console.log(newArr); //{ a: 'a', b: 'b', c: { name: 'hhh' } }

2.递归[如果是原始类型，无需继续拷贝，直接返回；如果是引用类型，创建一个新的对象，遍历需要克隆的对象，将需要克隆对象的属性执行深拷贝后依次添加到新对象上]

  function clone(target) {
    if (typeof target === 'object') {
        let cloneTarget = {};
        for (const key in target) {
            cloneTarget[key] = clone(target[key]);
        }
        return cloneTarget;
    } else {
        return target;
    }
};

module.exports = function clone(target) {
    if (typeof target === 'object') {
        let cloneTarget = Array.isArray(target) ? [] : {};
        for (const key in target) {
            cloneTarget[key] = clone(target[key]);
        }
        return cloneTarget;
    } else {
        return target;
    }
};

封装深拷贝（判断一下属性值的类型，如果是对象，递归调用深拷贝函数）

let deepCopy = function(obj){
    //只拷贝对象
    if(typeof obj !== "object") return;
    //根据obj的类型判断是新建一个数组还是对象
    let newObj = obj instanceof Array? []:{};
    //遍历obj，并且判断是obj的属性才拷贝
    for(let key in obj){
        if(obj.hasOwnProperty(key)){
            //如果obj的子属性是对象，则进行递归操作，否则直接赋值
            newObj[key] = typeof obj[key] === "object"? deepCopy(obj[key]) :obj[key];

        }
    }
    return newObj;
}

！函数不可拷贝

let arr = {
    a: 'one', 
    b: ()=>{
      console.log('test')
    }
  };

let newArr = JSON.parse( JSON.stringify(arr) );
console.log(arr);    // {a: "one", b: ()=>{console.log('test')}}
console.log(newArr); // {a: "one"} // 函数没有复制成功