深拷贝、浅拷贝、半深拷贝实现方法，不断完善中……

浅拷贝：        

        浅拷贝只复制对象的指针,即存在栈中的地址，新旧对象还是共用一块内存，修改任意一个对象两个对象都会改变。

//浅拷贝方法
//1.把一个对象赋值给一个变量
var obj = {
  name: 'zhangsan'
}
var obj1 = obj
obj1.name = 'zhangsan'
console.log(obj);//{ name: 'zhangsan' }
console.log(obj1);//{ name: 'zhangsan' }

// 2.for...in循环，有多层嵌套的对象遍历,内层对象为浅拷贝，最外层为深拷贝
var obj = {
  name: 'lisi',	//深拷贝
  sayName: {
    age: 10,	//浅拷贝
    friend: {
      name: 'pan' //浅拷贝
    }
  }
}
var obj1 = {}
for (var key in obj) {
  obj1[key] = obj[key]
}
console.log(obj1);//{ name: 'lisi', sayName: { age: 10, friend: { name: 'pan' } } }
obj1.name = 'zhangsan'
obj1.sayName.age = 16
obj1.sayName.friend.name = 'wei'
console.log(obj);//{{ name: 'lisi', sayName: { age: 16, friend: { name: 'wei' } } }
console.log(obj1);//{ name: 'zhangsan', sayName: { age: 16, friend: { name: 'wei' } } }

// 3.Object.assign(目标对象，源对象)只有源对象，没有目标对象时
var obj = {
  name: 'lisi',
  sayName: function () { }
}
var obj1 = Object.assign(obj)
obj1.name = 'zhangsan'
console.log(obj);//{ name: 'zhangsan', sayName: [Function: sayName] }
console.log(obj1);//{ name: 'zhangsan', sayName: [Function: sayName] }

//4.	ES6...拓展符解构
//数组
let arr = [1, [4, 2], 3]
let [...arr1] = arr
console.log(arr1, arr === arr1); //[ 1, [ 4, 2 ], 3 ] false

//数组
let arr = [1, [4, 2], 3]
let [...arr1] = arr
console.log(arr1, arr === arr1); //[ 1, [ 4, 2 ], 3 ] false

//对象
//如果对象里面嵌套有对象，嵌套的对象是浅拷贝，最外层的对象是深拷贝
//...复制的是对象里的key:value，不是引用地址
//如果对象obj1里面嵌套有对象sayName，则sayName的value是引用地址
let obj1 = {
    name: 'zhang',	//深拷贝
    friends: 'leery',		//深拷贝
    //age:{}被复制的value是引用地址，不是值，所以age对象里面的age1、class属性是浅拷贝
    age: {		//深拷贝
        age1: 12,	//浅拷贝
        class: 187	//浅拷贝
    }
}
let b = {
    ...obj1
}
// 修改前
console.log(obj1);
console.log(b);
// { name: 'zhang', friends: 'leery', age: { age1: 12, class: 187 } }    
// { name: 'zhang', friends: 'leery', age: { age1: 12, class: 187 } } 

// 修改第一层对象属性值
console.log('修改obj1.name后');
obj1.name = 'lisi'
console.log(obj1, 'obj1');
console.log(b, 'b');     //b的值不改变name: 'zhang'，深拷贝
// { name: 'lisi', friends: 'leery', age: { age1: 12, class: 187 } } obj1
// { name: 'zhang', friends: 'leery', age: { age1: 12, class: 187 } } b  

// 修改第二层对象属性值
console.log('修改obj1.age.age1后');
obj1.age.age1 = 15
console.log(obj1, 'obj1');
console.log(b, 'b');    //两个对象的属性值都改变age1: 15，浅拷贝 
// { name: 'lisi', friends: 'leery', age: { age1: 15, class: 187 } } obj1
// { name: 'zhang', friends: 'leery', age: { age1: 15, class: 187 } } b

// 修改obj1.age后
console.log('修改obj1.age后');
obj1.age = 10
console.log(obj1, 'obj1');
console.log(b, 'b');    //b的值不改变age: {}，深拷贝
// { name: 'lisi', friends: 'leery', age: 10 } obj1
// { name: 'zhang', friends: 'leery', age: { age1: 15, class: 187 } } b

//5.lodash clone
// 最外层的对象属性值是深拷贝  嵌套的对象是浅拷贝
var obj2 = _.clone(obj);
obj2.age = 20;//obj的age不变  深拷贝
obj.obj1.user = 'bbb'//obj2的obj.obj1.user一起改变  浅拷贝
console.log(obj);
console.log(obj2);//
// { name: 'zhangsan', age: 19, obj1: { user: 'bbb' } }
// { name: 'zhangsan', age: 20, obj1: { user: 'bbb' } }

  深拷贝：      

         深拷贝会创造一个一模一样的对象，新旧对象不再共用同一块内存，修改新对象旧对象不变。

// 深拷贝方法
// 1.JSON.parse(JSON.stringify())
var obj = {
  name: 'lisi',
  age: 12,
  sayName: function () {
    console.log(this.name);
  }
}
var obj1 = JSON.parse(JSON.stringify(obj))
console.log(obj1);//{ name: 'lisi', age: 12 }
obj1.name = 'zhangsan'
console.log(obj);//{ name: 'lisi', age: 12, sayName: [Function: sayName] }
console.log(obj1);//{ name: 'zhangsan', age: 12 }

// 2.for...in循环，给无嵌套的对象遍历
var obj = {
  name: 'lisi'
}
var obj1 = {}
for (var key in obj) {
  obj1[key] = obj[key]
}
console.log(obj1);//{ name: 'lisi' }
obj1.name = 'zhangsan'
console.log(obj);//{{ name: 'lisi' }
console.log(obj1);//{ name: 'zhangsan'}

// 3.Object.assign(目标对象，源对象)同时存在源对象和目标对象
//有嵌套对象时为半深拷贝
var obj = {
  name: 'lisi',	//深拷贝
  class:{
      number:110	//浅拷贝
  }
}
Object.assign(obj1, obj)
obj1.name = 'zhangsan'
console.log(obj);//{ name: 'lisi' }
console.log(obj1);//{ name: 'zhangsan' }

//4.lodash	clonedeep
// 深拷贝
// 引入lodash
var _ = require('lodash');
var obj = {
  name: 'zhangsan',
  age: 19,
  obj1: {
    user: 'aaa',
    f: {
      username: 'we'
    }
  }
}
// 使用lodash cloneDeep进行深拷贝 嵌套的对象也是深拷贝
var obj2 = _.cloneDeep(obj);
obj2.age = 22;
obj.obj1.user = 'bbb'
obj.obj1.f.username = 'ccc'
console.log(obj); 	//age:19不改变  深拷贝
console.log(obj2);	//obj2.obj1.f.username不变  深拷贝
// {
//   name: 'zhangsan',
//   age: 19,
//   obj1: { user: 'bbb', f: { username: 'ccc' } }
// }
// {
//   name: 'zhangsan',
//   age: 22,
//   obj1: { user: 'aaa', f: { username: 'we' } }
// }

//5.lodash	clone
// 最外层的对象属性值是深拷贝  嵌套的对象是浅拷贝
var obj2 = _.clone(obj);
obj2.age = 20;	//obj的age不变  深拷贝
obj.obj1.user = 'bbb'	//obj2的obj.obj1.user一起改变  浅拷贝
console.log(obj);
console.log(obj2);
// { name: 'zhangsan', age: 19, obj1: { user: 'bbb' } }
// { name: 'zhangsan', age: 20, obj1: { user: 'bbb' } }

//6.	ES6...拓展符解构
//数组
let arr = [1, [4, 2], 3]
let [...arr1] = arr
console.log(arr1, arr === arr1); //[ 1, [ 4, 2 ], 3 ] false

//对象
//如果对象里面嵌套有对象，嵌套的对象是浅拷贝，最外层的对象是深拷贝
let obj1={
  name:'zhang',	//深拷贝
  friends:'leery',		//深拷贝
  age:{
    age1:12,	//浅拷贝
    class:187	//浅拷贝
  }
}
let b={
  ...obj1
}
console.log(obj1,'修改前');
// { name: 'zhang', friends: 'leery', age: { age1: 12, class: 187 } } 修改前
console.log(b,'修改前');
// { name: 'zhang', friends: 'leery', age: { age1: 12, class: 187 } } 修改前

obj1.name='lisi'
obj1.friends='wangwu'
console.log(obj1,'obj1,修改后');
// { name: 'lisi', friends: 'wangwu', age: { age1: 12, class: 187 } } obj1,修改后
console.log(b,'b修改后');
// { name: 'zhang', friends: 'leery', age: { age1: 12, class: 187 } } b修改后

obj1.age.age1=15
obj1.age.class=155
console.log(obj1,'obj1,修改后');
// { name: 'lisi', friends: 'wangwu', age: { age1: 15, class: 155 } } obj1,修改后
console.log(b,'b修改后');
// { name: 'zhang', friends: 'leery', age: { age1: 15, class: 155 } } b修改后

obj1.friends='zhao'
console.log(obj1,'obj1,修改后');
// { name: 'lisi', friends: 'zhao', age: { age1: 15, class: 155 } } obj1,修改后
console.log(b,'b修改后');
// { name: 'zhang', friends: 'leery', age: { age1: 15, class: 155 } } b修改后

  半深拷贝： 

        有嵌套对象时为半深拷贝

//有嵌套对象时为半深拷贝
var obj = {
  name: 'lisi',	//深拷贝
  class:{
      number:110	//浅拷贝
  }
}
Object.assign(obj1, obj)
obj1.name = 'zhangsan'
console.log(obj);//{ name: 'lisi' }
console.log(obj1);//{ name: 'zhangsan' }