浅度拷贝和深度拷贝

浅度拷贝: 指的是拷贝一个对象时，仅仅拷贝对象的引用进行拷贝，但是拷贝对象和源对象还是引用同一份实体.
深度拷贝: 指的是拷贝一个对象时，不仅仅把对象的引用进行复制，还把该对象引用的值也一起拷贝.这样进行深拷贝后的拷贝对象就和源对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。

浅拷贝

复制引用，而未复制真正的值；原对象值和赋值后值的变化都会相互影响变化。

const originArray = [1,2,3,4,5];
const originObj = {a:'a',b:'b',c:[1,2,3],d:{dd:'dd'}};
 
const cloneArray = originArray;
const cloneObj = originObj;
 
console.log(cloneArray); // [1,2,3,4,5]
console.log(originObj); // {a:'a',b:'b',c:Array[3],d:{dd:'dd'}}
 
cloneArray.push(6);
cloneObj.a = {aa:'aa'};
 
console.log(cloneArray); // [1,2,3,4,5,6]
console.log(originArray); // [1,2,3,4,5,6]
 
console.log(cloneObj); // {a:{aa:'aa'},b:'b',c:Array[3],d:{dd:'dd'}}
console.log(originObj); // {a:{aa:'aa'},b:'b',c:Array[3],d:{dd:'dd'}}

深拷贝

对目标的完全复制，包括引用和值。

递归方式

   function handledeepClone() { 
       //判断拷贝的要进行深拷贝的是数组还是对象，是数组的话进行数组拷贝，对象的话进行对象拷贝   
       var objClone = Array.isArray(obj) ? [] : {};
      //进行深拷贝的不能为空，并且是对象或者是
      if (obj && typeof obj === "object") {
         for (key in obj) {
            if (obj.hasOwnProperty(key)) {
              if (obj[key] && typeof obj[key] === "object") {
                objClone[key] = handledeepClone(obj[key]);
              } else {
          objClone[key] = obj[key];
        }
      }
    }
  }
  return objClone;
   }

是真正意义上的递归，而递归遇到死循环会导致栈溢出，谨慎使用

Object.assign()方式（ES6）

     当对象中只有一级属性，没有二级属性的时候，此方法为深拷贝，但是对象中有对象的时候，此方法，在二级属性以后就是浅拷贝。
     Object.assign(target, ...sources)

Object.assign() 拷贝的是属性值。假如源对象的属性值是一个指向对象的引用，它也只拷贝那个引用值

JSON对象方式

通过js的内置对象JSON来进行数组对象的深拷贝
function deepClone(obj) {
  var _obj = JSON.stringify(obj),
    objClone = JSON.parse(_obj);
  return objClone;
}

此方法在对undefined,function,symbol转换过程中忽略

jQuery的extend方式

var array = [a,b,c];
var newArray = $.extend(true,[],array);

lodash函数库方式

   lodash很热门的函数库，提供了 lodash.cloneDeep()实现深拷贝

数组中的拷贝

for循环

  //数组情况
let arr = [1,3,6,9];
let res = [];
for(let val of arr){
    res.push(val)
}

//对象情况
let obj = [1,3,6,9];
let res = [];
for(let key in obj){
    res[key] = obj[key]
}

slice方法（原数组的拷贝的，这两个方法都不会修改原数组，而是返回一个修改后的新数组）

let arr = [1,5,6,8,9];
let arr2 = arr.slice(0); //从0位置开始截取

slice 只是对数组的第一层进行深拷贝

concat方法（原数组的拷贝的，这两个方法都不会修改原数组，而是返回一个修改后的新数组）

let arr = [1,5,6,8,9];
let arr2 = arr.concat()

concat 只是对数组的第一层进行深拷贝

es6扩展对象

//数组
var arr = [1,2,3,4,5]
var [ ...arr2 ] = arr
//对象
var obj = {
 a: 111,
 b: 222
}
var { ...obj2 } = obj

... 实现的是对象第一层的深拷贝。后面的只是拷贝的引用值