深拷贝和浅拷贝

深拷贝和浅拷贝

• 浅拷贝对于基本数据类型（number,boolean,string,null,undefined），拷贝的是数据的值，对于引用数据类型（object），拷贝的是数据的内存地址

• 深拷贝对比浅拷贝，深拷贝需要拷贝到引用数据类型中堆里面的值，并开辟新的堆空间，且修改新对象不会影响原对象。

var a1 = { b: { c: {} } }

var a2 = shallowClone(a1) // 浅拷贝方法
a2.b.c === a1.b.c // true 新旧对象还是共享一块内容

var a3 = deepClone(a1) // 深拷贝方法
a3.b.c === a1.b.c // false 新对象跟旧对象不共享内容

总结：浅拷贝只复制指向某个对象的指针，而不赋值对象本身，新旧对象还是共享一块内存。但深拷贝会创造一个一模一样的对象，新对象跟原对象不共享内存,修改新对象不会改变原对象

---

赋值和深/浅拷贝的区别

这三者区别如下，不过比较的前提都是针对引用类型

• 当我们把一个对象赋值给一个新的变量时，赋的其实是该对象的在栈中的地址，而不是堆中的数据。也就是两个对象指向的是同一个存储空间，无论哪个对象发生改变，其实都是改变的存储空间的内容，因此，两个对象是联动的。
• 浅拷贝：重新在堆内存中创建内存，拷贝前后基本数据类型互不影响，但拷贝前后对象的引用类型因共享一块内存，会互相影响。
• 深拷贝：从堆内存中开辟一个新的区域存放新对象，对对象中的子对象进行递归拷贝，拷贝前后的两个对象互不影响。

我们先来看下面的例子，对比赋值与深/浅拷贝得到的对象修改后对原始对象的影响：

// 对象赋值
let obj1 = {
    name : whl',
    arr : [1,[2,3],4],
};
let obj2 = obj1;
obj2.name = "whl";
obj2.arr[1] =[5,6,7] ;
console.log('obj1',obj1) // obj1 { name: 'whl', arr: [ 1, [ 5, 6, 7 ], 4 ] }
console.log('obj2',obj2) // obj2 { name: 'whl', arr: [ 1, [ 5, 6, 7 ], 4 ] }

// 浅拷贝
let obj1 = {
    name : 'whl',
    arr : [1,[2,3],4],
};
let obj3=shallowClone(obj1)
obj3.name = "qwe";
obj3.arr[1] = [5,6,7] ; // 新旧对象还是共享同一块内存
// 这是个浅拷贝的方法
function shallowClone(source) {
	var taget = {}
	for(let i in source) {
		if(source.hasOwnProperty(i)) {
			target[i] = source[i]
        }
    }
    return target
}
console.log('obj1',obj1) // obj1 { name: 'whl', arr: [ 1, [ 5, 6, 7 ], 4 ] }
console.log('obj3',obj3) // obj3 { name: 'qwe', arr: [ 1, [ 5, 6, 7 ], 4 ] }

// 深拷贝
let obj1 = {
    name : 'whl',
    arr : [1,[2,3],4],
};
let obj4=deepClone(obj1)
obj4.name = "qwe";
obj4.arr[1] = [1,2,3] ; // 新对象跟原对象不共享内存
// 这是个深拷贝的方法
function deepClone(obj, hash = new WeakMap()) {
  if (obj === null || typeof obj !== "object") return obj; // 如果是null或者undefined我就不进行拷贝操作,// 可能是对象或者普通的值  如果是函数的话是不需要深拷贝
  if (obj instanceof Date) return new Date(obj);
  if (obj instanceof RegExp) return new RegExp(obj);
  // 是对象的话就要进行深拷贝
  if (hash.get(obj)) return hash.get(obj);
  let cloneObj = new obj.constructor();
  // 找到的是所属类原型上的constructor,而原型上的 constructor指向的是当前类本身
  hash.set(obj, cloneObj);
  for (let key in obj) {
    if (obj.hasOwnProperty(key)) {
      // 实现一个递归拷贝
      cloneObj[key] = deepClone(obj[key], hash);
    }
  }
  return cloneObj;
}
console.log('obj1',obj1) // obj1 { name: 'whl', arr: [ 1, [ 2, 3 ], 4 ] }
console.log('obj4',obj4) // obj4 { name: 'qwe', arr: [ 1, [ 1, 2, 3 ], 4 ] }

上面例子中，obj1是原始对象，obj2是赋值操作得到的对象，obj3浅拷贝得到的对象，obj4深拷贝得到的对象

---

浅拷贝的实现方式

• 1.Object.assign()（只能处理深度只有一层的对象）
• Object.assign() 方法可以把任意多个的源对象自身的可枚举属性拷贝给目标对象，然后返回目标对象。

let obj1 = { person: {name: "kobe", age: 41},sports:'basketball' };
let obj2 = Object.assign({}, obj1);
obj2.person.name = "wade";
obj2.sports = 'football'
console.log(obj1); // { person: { name: 'wade', age: 41 }, sports: 'basketball' }

• 2.函数库lodash的_.clone方法

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

• 3.展开运算符...

let obj1 = { name: 'Kobe', address:{x:100,y:100}}
let obj2= {... obj1}
obj1.address.x = 200;
obj1.name = 'wade'
console.log('obj2',obj2) // obj2 { name: 'Kobe', address: { x: 200, y: 100 } }

• 4.Array.prototype.concat()

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

• 5.Array.prototype.slice()

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

---

深拷贝的实现方式

• JSON.parse(JSON.stringify())

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

这也是利用JSON.stringfy将对象转换成字符串，再用JSON.parse把字符串解析成对象，而且对象会开辟新的栈，实现深拷贝。

这种方法虽然可以实现数组或对象深拷贝,但不能处理函数和正则，因为这两者基于JSON.stringify和JSON.parse处理后，得到的正则就不再是正则（变为空对象），得到的函数就不再是函数（变为null）了。

比如下面的例子:

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

---

• 手写深拷贝
• 递归方法实现深拷贝原理: 遍历对象、数组直到里面都是基本数据类型，然后再去赋值，就是深拷贝
• 有种特殊情况需注意就是对象存在循环引用的情况，即对象的属性直接的引用了自身的情况，解决循环引用问题，我们可以额外开辟一个存储空间，来存储当前对象和拷贝对象的对应关系，当需要拷贝当前对象时，先去存储空间中找，有没有拷贝过这个对象，如果有的话直接返回，如果没有的话继续拷贝，这样就巧妙化解的循环引用的问题。

function deepClone(obj, hash = new WeakMap()) {
  if (obj === null || typeof obj !== "object") return obj; // 如果是null或者undefined我就不进行拷贝操作,// 可能是对象或者普通的值  如果是函数的话是不需要深拷贝
  if (obj instanceof Date) return new Date(obj);
  if (obj instanceof RegExp) return new RegExp(obj);
  // 是对象的话就要进行深拷贝
  if (hash.get(obj)) return hash.get(obj);
  let cloneObj = new obj.constructor();
  // 找到的是所属类原型上的constructor,而原型上的 constructor指向的是当前类本身
  hash.set(obj, cloneObj);
  for (let key in obj) {
    if (obj.hasOwnProperty(key)) {
      // 实现一个递归拷贝
      cloneObj[key] = deepClone(obj[key], hash);
    }
  }
  return cloneObj;
}
let obj = { name: 1, address: { x: 100 } };
obj.a = obj; // 对象存在循环引用的情况
let f = deepClone(obj);
obj.address.x = 200;
console.log(f);