首先，深拷贝和浅拷贝针对的是对象类型（对象，数组，函数）。
浅拷贝指的是只是拷贝了对象的引用地址，彼此之间高耦合，一个改变，另一个可能也随之改变；
深拷贝是指只是完整的将变量的值拷贝过来，是一个新的对象，和被拷贝对象解耦合，一个改变，不会影响其它的内容。
浅拷贝
当对象有多层属性值时，只拷贝第一层, 是浅拷贝。如果被拷贝对象只有一层，下面的方法就是深拷贝。
1）对象遍历赋值
let copy = function(target,source){
for(let property in source){
target[property] = source[property]
}
return target;
}
2) 对象合并函数Object.assign({})--复制可遍历属性（元属性enumerable为true）
当Object.assign(obj)只有一个参数时，相当于返回自身。
let copy = Object.assign(obj); // copy === obj// 注意：当obj的值为原始类型的值(boolean,string,number)时，会将原始值转为包装对象。当obj为undefined或者null时，无法转为对象会报错。 当Object.assign(target, source1, source2,...)有多个参数时,将第一个设为空对象{}
// 浅拷贝
let copy = Object.assign({}, source);
// 注意： 当source为undefined或者null或者（boolean,number）时，会忽略source;当source为string类型时，会将字符串转为对象
Object.assign({},str) ---> //{0: "a", 1: "b", 2: "c"}
3）扩展运算符（...）性质同1）
let a = {
age: {
my: 18
}
}
let b = {...a};
b.age.my = 20;
a; //{age: {my: 20}}
4) [xxx].slice() 浅拷贝
var a = [[1,2,3]]; //目标对象是多维数组
var b = slice();
b[0][0] = 100;
a; // [[100,2,3]]
深拷贝
为了不出现上面例子中，嵌套关系拷贝只拷贝地址的情况，我们需要遍历到最底层，逐级赋值，实现深拷贝
1.JSON.parse(JSON.stringify(obj))
该方法可以解决大多数的深拷贝问题。实际开发任务中，基本都可以使用。但是有些特殊情况：
具体使用JSON.stringify的特殊的情况如下：
1）忽略属性值为undefined和function类型和Symbol类型的值；
JSON.parse(JSON.stringify({a:1, b:function(){}, c:undefined, d: Symbol()}))
// 结果如下：
{a: 1}
2) 值为Regex,Error类型的值会变成空对象{};
JSON.parse(JSON.stringify({a:1, b: RegExp('a'), c: new Error('err')}));
// 结果
{a:1, b: {}, c: {}}
3) 值NaN,Infinity,-Infinity的值会变成null;
JSON.parse(JSON.stringify({a:1, b: NaN, c:Infinity, d: -Infinity}))
// 结果
{a:1, b: null, c: null, d: null}
4)不能序列化循环引用的对象,会抛出异常
var a = {};
a.b = a;
JSON.stringify(a);
// Uncaught Error: Converting circular structure to JSON
5)当参数对象有自定义的toJSON()方法时，JSON.stringify()会将该方法的返回值作为最后的参数值，忽然其它的参数。
6)当参数值为Date对象类型时，因为Date对象有toJSON()方法，则JSON.stringify()会将Date类型的值按照字符串转换，
然后JSON.parse()去解析JSON字符串，最终会解析成字符串，不会解析成Date类型。
2.通用的深拷贝方法
1)直接使用lodash中的cloneDeep方法
2)手写一个深拷贝方法
function deepClone(obj, hash=new WeakMap()) {
// 如果obj为null/undefined
if(obj == null){// null == undefined
return obj;
}
if (obj instanceof RegExp) {
return new RegExp(obj); //拷贝正则对象，需要新生成一个对象
}
if (obj instanceof Date) {
return new Date(obj);
}
if(obj instanceof Error) {
return new Error(obj);
}
// 如果是原始类型的值（string/number/boolean/symbol）或者function
// function不需要被拷贝，使用时是调用
if(typeof obj !== 'object'){
return obj;
}
// 如果是对象(Array,Object)需要递归拷贝
if(hash.get(obj)) return hash.get(obj);
let cloneObj = new obj.constructor;
// 防止出现对象属性循环调用自身的情况: var a ={}; a.b= a;
hash.set(obj, cloneObj);
for(let key in obj) {
if (obj.hasOwnProperty(key)) {// 只拷贝自身的属性
cloneObj[key] = deepClone(obj[key], hash);
}
}
return cloneObj;
}
//测试
var a = {a:1, b:function(){}, c:undefined, d: Symbol()};
var b = {a:1, b: RegExp('a'), c: new Error('err')};
var c = {a:1, b: NaN, c:Infinity, d: -Infinity};
var d = {a:1, b: new Date()}
var e = {}; e.a = e;
console.log(deepClone(a)); // {a:1, b:function(){}, c:undefined, d: Symbol()};
console.log(deepClone(b)); // {a:1, b: RegExp('a'), c: new Error('err')};
console.log(deepClone(b)); // {a:1, b: NaN, c:Infinity, d: -Infinity};
console.log(deepClone(d)); // {a:1, b: new Date()}
console.log(deepClone(e)); // {a: [Circular]}