1.使用slice或者concat进行数组深拷贝

• 对于值都是普通数据类型的数组，可以使用数组的slice或者concat函数来进行深拷贝。

let a = [1, 2, 3]
let b = a.slice(0) //或者 let b = a.concat()
b[0] = 0
console.log(a[0] === 1) //true,改变b不影响a

• 若数组的项不是普通数据类型，而是引用数据类型，则使用slice或concat进行拷贝则只能进行一层深拷贝，也就是数组项内部不能进行深拷贝。如下，数组第一项为一个对象，改变b数组第一项中对象的key属性值，对应的a数组也被改变了。

let a = [{
  key: 1
}]
let b = a.slice(0) //或者 let b = a.concat()
b[0].key = 0
console.log(a[0].key === 0) //true,改变b影响a

2.使用JSON序列化函数进行深拷贝

function deepColne(obj) {
  return JSON.parse(JSON.stringify(obj))
}

1.支持数组和常规对象深拷贝

let obj = [{
  key: 1
}]
let newObj = colne(obj)
newObj[0].key = 0
console.log(obj[0].key) // 1

2.不支持undefined，会转成null

let a = [1, , 2]
let b = colne(a)
console.log(a[1]) // undefined
console.log(b[1]) // null

3.不支持函数、RegExp、Date对象，会报错

let func = function() {
  console.log(1)
}
let newFunc = colne(func)  //这直接报错

3.使用递归进行对象深拷贝（递归为深度优先）

function deepColne(obj) {
  let newObj
  if(obj === null) {
    return null
  } 
  else if (! (obj instanceof Object)) {
    return obj
  } 
  else if (obj instanceof Date) {
    return new Date(obj)
  }
  else if (obj instanceof RegExp) {
    return new RegExp(obj)
  }
  else if (obj instanceof Function) {
    //经测试复制函数有问题
    return eval(obj.toString())
  }
  else if (obj instanceof Array) {
    newObj = []
    for(item of obj) {
      newObj.push(clone(item))
    }
  }
  else {
    newObj = Object.create(null)
    for(let key of Object.keys(obj)) {
      newObj[key] = clone(obj[key])
    }
  }
  return newObj
}

-缺陷：1）经测试函数拷贝有问题；2）不支持环的情况：对象的某个属性值是对象本身，若出现环会循环递归，造成内存溢出。

4.使用宽度优先 + 队列实现深拷贝，解决出现环的问题

-注意：不支持函数

function deepClone(obj) {
  if(obj === null) {
    return null
  } 
  /*obj是Date类型 */
  else if (obj instanceof Date) {
    return new Date(obj)
  }
  /*obj是正则表达式类型 */
  else if (obj instanceof RegExp) {
    return new RegExp(obj)
  }
  /*obj是数组或者普通对象*/
  let newObj = (obj instanceof Array) ? [] : {},
    srcQueue = [obj],
    srcVisitedQueue = [],
    copyQueue = [newObj],
    copyVisitedQueue = [];

  while (srcQueue.length > 0) {
    let currentSrcElement = srcQueue.shift(),
      currentCopyElement = copyQueue.shift();

    srcVisitedQueue.push(currentSrcElement);
    copyVisitedQueue.push(currentCopyElement);

    for (let key in currentSrcElement) {
      /*基础数据类型直接复制*/
      if (typeof currentSrcElement[key] !== 'object') {
        currentCopyElement[key] = currentSrcElement[key];
      } 
      /*日期对象*/
      else if (currentSrcElement[key] instanceof Date) {
        currentCopyElement[key] = new Date(currentSrcElement[key])
      }
      /*正则*/
      else if (currentSrcElement[key] instanceof RegExp) {
        currentCopyElement[key] = new RegExp(currentSrcElement[key])
      }
      /*对象数据类型或者数组*/
      else {
        // 有环的情况：判断该对象是否已被访问
        let index = srcVisitedQueue.indexOf(currentSrcElement[key]);        
        if (index >= 0) {
          currentCopyElement[key] = copyVisitedQueue[index];  //环（已访问）直接复制
        } 
        else {
          //非环对象或数组加入到源队列
          srcQueue.push(currentSrcElement[key]);  
          //copy对象对应位置暂时放置空对象或空数组，下一轮循环赋值
          currentCopyElement[key] = currentSrcElement[key] instanceof Array ? [] : {};      
          copyQueue.push(currentCopyElement[key]); 
        }
      }
    }
  }
  return newObj
}