直接赋值浅拷贝

---

平时操作数组，用赋值的方法，那么我们只要更改其中的任何一个，然后其他的也会跟着改变

var arr1 = [1,2,3]
var arr2[0] = -1 
console.log(arr1)  // [-1, 2, 3]
console.log(arr2)  // [-1, 2, 3]

Object.assign()

---

对象里面第一层是基本类型进行深拷贝，对象引用类型进行浅拷贝

var arr1 = {a:0, b: {c: 2}};
var arr2 = Object.assign({}, arr1)  
arr2.a = 1
console.log(arr1);  // {a:0, b: {c: 2}};   基本类型进行深拷贝 不会被改变
console.log(arr2);    // {a:1, b: {c: 2}};

var arr1 = {a:0, b: {c: 2}};
var arr2 = Object.assign({}, arr1)  
arr2.b.c = 1
console.log(arr1);  // {a:0, b: {c: 1}};  引用类型进行浅拷贝 都被改变了
console.log(arr2);    // {a:0, b: {c: 1}};

slice() 和 concat()

---

对基本类型进行深拷贝，对引用类型进行浅拷贝，这两个方法仅适用于对不包含引用对象的一维数组的深拷贝

• 基本类型是深拷贝

var arr1 = [1,2,3];
var arr2 = arr1.slice(0);   // 或者 var arr2 = arr1.concat();
arr2[0] = -1;
console.log(arr1); // [1, 2, 3]
console.log(arr2);  // [-1, 2, 3]

• 引用类型浅拷贝

var arr1 = [{a: 1}, {b: 2}];
var arr2 = arr1.slice(0);   // 或者 var arr2 = arr1.concat();
arr2[0].a = 2
console.log(arr1); //  [{a: 2}, {b: 2}];
console.log(arr2);  //  [{a: 2}, {b: 2}];

JSON.parse(JSON.stringfy)

---

实现深拷贝原理：堆栈开辟新内存空间，实现深拷贝

var obj = {
    name: 'ysk',
    arr : [1,2,3]
}
var targetObj = JSON.parse(JSON.stringify(obj))
// copyObj.arr !== targetObj.arr   // 实现深拷贝

缺陷：

1. 如果你的对象里有函数,函数无法被拷贝下来
2. 无法拷贝copyObj对象原型链上的属性和方法
3. 实际场景可能对象里并没有函数，原型链上并没有属性和方法，大多数场景可以直接上JSON.parse(JSON.stringify(obj))

递归

---

缺陷：

爆栈，数据的层次很深，递归就会栈溢出，如何解决呢？

首先介绍尾调用, 函数m和n都属于尾调用，因为它们都是函数f的最后一步操作。

  function f(x) {
    if (x > 0) {
      return m(x)
    }
    return n(x);
  }

再来看一下普通递归 复杂度 O(n)

  function factorial(n) {
    if (n === 1) return 1;
    return n * factorial(n - 1);
  } 

通过Map这种数据结构对相同值的计算进行保存

      let mapData = new Map()
      function fib(n){
        if(n == 0 || n ==1) return 1;
        if(mapData.get(n)){  //这一步就避免了重复计算
            return mapData.get(n);
        }
        let value = fib(n-1) + fib(n-2)
        mapData.set(n, value)
        return value
      } 

递归也会引起循环引用的问题，如何解决呢？

• 是通过存储键值对一样的对象。包括你深拷贝最终返回的对象。就是说你Map中有一个键值对就是key是目标对象，value也是目标对象。当有循环引用，递归调用时，就会加一个条件，如果map中有这个对象的话，直接返回这个对象。

• 前提是，每一次递归的时候，我们保存了这个对象为key，value也为这个对象的键值对在Map中。

        function deepCopy(obj, map = new Map()) {
          if (typeof obj === 'object') {
            let res = Array.isArray(obj) ? [] : {}
              if(map.get(obj)) {
                return map.get(obj)
              } 
              map.set(obj, res)
              for(var i in obj) {
                res[i] = deepCopy(obj[i], map)
              }
              return map.get(obj)
          } else {
            return obj
          }
        }
  

第三方库

---

1. loadash 中的 cloneDeep
2. immer

proxy

---

1. 使用proxy拦截来判断是否对象有改变
2. 拦截set，所有赋值都在 copy （原数据浅拷贝的对象）中进行，这样就不会影响到原对象