理解深拷贝和浅拷贝浅拷贝深拷贝赋值和深/浅拷贝的区别（针对引用类型的比较）实现浅拷贝展开运算符...（ES6的新特性）

浅拷贝

创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝
如果属性是基本类型，拷贝的就是基本类型的值，如果属性是引用类型，拷贝的就是内存地址
所以如果其中一个对象改变了这个地址，就会影响到另一个对象
var a1 = {b: {c: {}};
var a2 = shallowClone(a1);   // 浅拷贝方法
a2.b.c === a1.b.c            // true 新旧对象还是共享同一块内存

深拷贝

将一个对象从内存中完整的拷贝一份出来,从堆内存中开辟一个新的区域存放新对象，修改新对象不会影响原对象
var a1 = {b: {c: {}};
var a3 = deepClone(a3);      // 深拷贝方法
a3.b.c === a1.b.c            // false 新对象跟原对象不共享内存

赋值和深/浅拷贝的区别（针对引用类型的比较）

当我们把一个对象赋值给一个新的变量时，赋的其实是该对象的在栈中的地址，而不是堆中的数据
也就是两个对象指向的是同一个存储空间，无论哪个对象发生改变，其实都是改变的存储空间的内容

浅拷贝：重新在堆中创建内存，拷贝前后对象的基本数据类型互不影响
但拷贝前后对象的引用类型因共享同一块内存，会相互影响

深拷贝：从堆内存中开辟一个新的区域存放新对象，对 对象中的子对象进行递归拷贝
拷贝前后的两个对象互不影响

实现浅拷贝

展开运算符 ...（ES6的新特性）

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

Array.prototype.concat()

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

Array.prototype.slice()

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

实现深拷贝

jQuery.extend()

$.extend(deepCopy, target, object1, [objectN])   //第一个参数为true,就是深拷贝

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

JSON.parse(JSON.stringify())

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

用JSON.stringify将对象转成JSON字符串，再用JSON.parse把字符串解析成对象，产生了新对象
而且对象会开辟新的栈，实现深拷贝，这种方法虽然可以实现数组或对象深拷贝,但不能处理函数和正则
因为这两者基于JSON.stringify和JSON.parse处理后
得到的正则就不再是正则（变为空对象），得到的函数就不再是函数（变为null）了

手写递归方法实现深拷贝

使用递归方法实现深拷贝，遍历对象，数组，直到里面都是基本数据类型，然后在去拷贝
需要判断类型，不同类型不同的拷贝方法
检查环，也叫循环引用（如果一个对象引用了自己，在递归时有可能出不来）
可以开辟一个存储空间，来存储当前对象和拷贝对象的对应关系，当需要拷贝当前对象时，先去存储空间找
是否拷贝过这个对象，有就直接返回，没有就继续拷贝，解决了循环引用
需要忽略原型，不拷贝原型__proto__，浪费内存

function deepClone(obj, hash = new WeakMap()){
  if(obj === null) return obj;                  //如果要拷贝的obj是空，就不进行拷贝操作
  if(obj instanceof Date) return new Date(obj); //如果要拷贝的类型是Date，就返回这个日期
  if(obj instanceof RexExp) return new RexExp(obj); //如果要拷贝的类型是正则，就返回这个正则
  if(typeof obj !== "object") return obj;          //如果要拷贝的是基本类型，直接拷贝
  if(hash.get(obj)) return hash.get(obj);  //判断hash里是否有要拷贝的对象，有就返回之前的结果
  let cloneObj = new obj.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.o = obj;                              //对象存在循环引用的情况
let d = deepClone(obj);
obj.address.x = 200;
console.log(d);

理解 深拷贝和浅拷贝

实现浅拷贝

实现深拷贝

理解深拷贝和浅拷贝