一、 基本数据类型的拷贝（复制copy）深拷贝和浅拷贝
深拷贝和浅拷贝是针对复杂数据类型来说的，浅拷贝只拷贝一层，而深拷贝是层层拷贝
基本数据类型 值传递
a = 1.1;b = a;b = 2; console.log(a,b) Number
a = 'hello';b = a;b = 3; console.log(a,b) String
a = false;b = a;b = 'sss'; console.log(a,b) Boolean
a = undefined;b = a;b = false; console.log(a,b) Undefined
a = null;b = a;b = undefined; console.log(a,b) Null
深拷贝
深拷贝复制变量值，对于非基本类型的变量，则递归至基本类型变量后，再复制。 深拷贝后的对象与原来的对象是完全隔离的，互不影响，对一个对象的修改并不会影响另一个对象。
浅拷贝
浅拷贝是会将对象的每个属性进行依次复制，但是当对象的属性值是引用类型时，实质复制的是其引用，当引用指向的值改变时也会跟着变化。
可以看出浅拷贝只最第一层属性进行了拷贝，当第一层的属性值是基本数据类型时，新的对象和原对象互不影响，但是如果第一层的属性值是复杂数据类型，那么新对象和原对象的属性值其指向的是同一块内存地址。
二、复杂数据类型（object）的拷贝 地址传递
常用的复杂数据类型包括：{ }、[ ]、function(){} 、Date（时间） 、RegExp 、null（这个比较特殊）等
1、我们依然用一的简单赋值（=）来进行一遍操作（赋值）
经过实践我们会发现：
1、当类型为{}、[]的时候，改变b的值，a也会跟着一起变化。
2、当类型为Date、function、RegExp的时候，a保持不变。
总结：我们发现{}或者[]时，简单的赋值操作并不能实现它们的拷贝，只是改了b的指向，使a和b都指向同一个引用，随意改变一个，都会影响另外一个的值。
// {}
// a = {name: 'abc'};b = a;b.name = 'sss';
// console.log(a,b)
// // []
// a = ['a','b','c'];b = a;b[1] = 'd';
// console.log(a,b)
// // function
// a = function(){ alert('aaa'); };b = a;b = function(){ alert('bbb'); };
// console.log(a.toString(),b.toString())
// // Date
// a = new Date('2018-10-11 00:00:00');b = a;b = new Date('1970-01-01 00:00:00');
// console.log(a,b)
// // RegExp
// a = new RegExp('abc');b = a;b = new RegExp('aaa');
// console.log(a,b)
// 2、Object.assign 和 for in进行{}和[]的拷贝（浅拷贝--只能拷贝一层）
// Object.assign
// a = {name: 'aaa'};b = Object.assign({}, a);
// b.name = 'bbb';
// console.log(a,b)
// a = [1,2,3];b = Object.assign([], a);b[1] = 4;
// console.log(a,b)
// // for in
// var copy = function(a) {
// var res = a.constructor();
// console.log(res)
// for(var key in a) {
// if(a.hasOwnProperty(key)) {
// res[key] = a[key];
// }
// }
// return res;
// }
// a = {name: 'aaa'};b = copy(a);b.name = 'bbb';
// console.log(a,b)
// a = [1,2,3];b = copy(a);b[1] = 4;
// console.log(a,b)
// a = {name:'aaa',people:{name: 'abc'}};b = Object.assign({}, a);b.people.name = 'def';
// console.log(a,b)
// // for in
// var copy = function(a) {
// var res = a.constructor();
// for(var key in a) {
// if(a.hasOwnProperty(key)) {
// res[key] = a[key];
// }
// }
// return res;
// }
// a = {name:'aaa',people:{name: 'abc'}};b = copy(a);b.people.name = 'def';
// console.log(a,b)
// a = [1,2, {name: 'aaa'}];b = Object.assign([], a);b[2].name = 'bbb';
// console.log(a,b)
// a = [1,2, {name: 'aaa'}];b = copy(a);b[2].name = 'bbb';
// console.log(a,b)
深拷贝和浅拷贝是针对复杂数据类型来说的，浅拷贝只拷贝一层，而深拷贝是层层拷贝。
深拷贝
深拷贝复制变量值，对于非基本类型的变量，则递归至基本类型变量后，再复制。 深拷贝后的对象与原来的对象是完全隔离的，互不影响，对一个对象的修改并不会影响另一个对象。
浅拷贝
浅拷贝是会将对象的每个属性进行依次复制，但是当对象的属性值是引用类型时，实质复制的是其引用，当引用指向的值改变时也会跟着变化。 可以使用 for in、 Object.assign、 扩展运算符 ... 、Array.prototype.slice()、Array.prototype.concat() 等
// var array = [
// { number: 1 },
// { number: 2 },
// { number: 3 }
// ];
// var copyArray = array.slice();
// copyArray[0].number = 100;
// console.log(array);
// console.log(copyArray);
// let obj = {
// name: 'Yvette',
// age: 18,
// hobbies: ['reading', 'photography']
// }
// let obj2 = Object.assign({}, obj);
// let obj3 = {...obj};
// obj.name = 'Jack';
// obj.hobbies.push('coding');
// console.log(obj);
// console.log(obj2);
// console.log(obj3);
可以看出浅拷贝只最第一层属性进行了拷贝，当第一层的属性值是基本数据类型时，新的对象和原对象互不影响，但是如果第一层的属性值是复杂数据类型，那么新对象和原对象的属性值其指向的是同一块内存地址。
1.深拷贝最简单的实现是: JSON.parse(JSON.stringify(obj))
JSON.parse(JSON.stringify(obj)) 是最简单的实现方式，但是有一些缺陷：
//对象的属性值是函数时，无法拷贝。
// 原型链上的属性无法拷贝
// 不能正确的处理 Date 类型的数据
// 不能处理 RegExp
// 会忽略 symbol
// 会忽略 undefined
递归函数
如果一个函数在内部调用自身，这个函数就叫做递归函数
递归函数：
实现一个 deepClone 函数 （深拷贝，完美）
// 如果是基本数据类型，直接返回
// 如果是 RegExp 或者 Date 类型，返回对应类型
// 如果是复杂数据类型，递归。
// 考虑循环引用的问题
// var show={
// btn:"btn",
// init:function(){
// var that=this;
// alert(this);
// this.btn.click(function(){
// that.change();
// alert(this);
// })
// },
// change:function(){
// this.btn.css({'background':'green'});
// person={
// name:"king",
// show:function(){
// console.log(this.name)
// }
// }
// }
// }
// function deepClone(obj, hash = new WeakMap()) { //递归拷贝
// if (obj instanceof RegExp) return new RegExp(obj);
// if (obj instanceof Date) return new Date(obj);
// if (obj === null || typeof obj !== 'object') {
// //如果不是复杂数据类型，直接返回
// return obj;
// }
// if (hash.has(obj)) {
// return hash.get(obj);
// }
/**
* 如果obj是数组，那么 obj.constructor 是 [Function: Array]
* 如果obj是对象，那么 obj.constructor 是 [Function: Object]
*/
// let t = new obj.constructor();
// hash.set(obj, t);
// for (let key in obj) {
// //递归
// if (obj.hasOwnProperty(key)) {//是否是自身的属性
// t[key] = deepClone(obj[key], hash);
// }
// }
// return t;
// }
// var show2 = cloneObject(show)
// console.log(show2)
//递归函数
// function cloneObject (obj) {
// var newObj = {} //如果不是引用类型，直接返回
// if (typeof (obj) !== 'object') {
// return obj
// }
// //如果是引用类型，遍历属性
// else{
// for (var attr in obj) {
// //如果某个属性还是引用类型，递归调用
// newObj[attr] = cloneObject(obj[attr])
// }
// }
// return newObj
// }
