深浅拷贝问题

---针对引用类型

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

JavaScript 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也随之变动，所以，这是浅拷贝。 （创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值，如果属性是引用类型，拷贝的就是内存地址，所以如果其中一个对象改变了这个地址，就会影响到另一个对象。） JavaScript 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' }
• 方法
• 数组

1. Array.concat()
   JavaScript 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' ]
2. Array.slice()
   JavaScript 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' ]

• 对象

1. Object.assign() 可以把任意多个源对象自身的可枚举属性拷贝给目标对象，然后返回目标对象
   JavaScript 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' }
2. ES6扩展符{...Object} JavaScript 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' }

• 封装浅拷贝 （遍历需要克隆的对象，然后把需要克隆对象的属性和属性值都依次放在一个新的对象中，返回。） JavaScript 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。深拷贝将数据完全复制到新开辟的内存空间中。（将一个对象从内存中完整的拷贝一份出来，从堆内存中开辟一个新的区域存放新对象，且修改新对象不会影响原对象。）
  JavaScript 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());
  JavaScript 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.递归[如果是原始类型，无需继续拷贝，直接返回；如果是引用类型，创建一个新的对象，遍历需要克隆的对象，将需要克隆对象的属性执行深拷贝后依次添加到新对象上]

JavaScript       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;         }     };     ```   
* 封装深拷贝（判断一下属性值的类型，如果是对象，递归调用深拷贝函数）     
```JavaScript     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;     }     ```  
！函数不可拷贝 
```JavaScript 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"} // 函数没有复制成功 ```   
[https://www.notion.so/003-86d95731f5394ff3909864547dac1c21](参考！)