深拷贝与浅拷贝

前言

JS 数据类型

• 基本数据类型：String、Boolean、Number、Undefined、Null
• 引用数据类型：Object（Array、Date、RegExp、Function）

区别

保存位置不同：基本数据类型，名字和值（键值）都存储在栈内存中；引用数据类型，名字存在栈内存中，值存在堆内存中，但栈内存会提供一个引用的地址指向堆内存的值。

原因：

• 堆比栈大，栈比堆速度快；
• 基本数据类型稳定，相对来说占用的内存小；
• 引用类型数据大小是动态且无限的，所以将值存在堆中；
• 堆内存是无序存储，可以根据引用直接获取

因此，深拷贝与浅拷贝只针对于引用数据类型来说的。

定义

浅拷贝：只复制指向某个对象的指针，而不复制对象本身，新旧对象还是共享同一块内存。

深拷贝：会另外创造一个一摸一样的对象，新对象和原对象不共享内存，修改新对象不会改变原对象。

区别 ：浅拷贝只复制对象的第一层属性、深拷贝可以对对象的属性进行递归复制

浅拷贝的实现

1. for···in 只循环第一层

   // 只复制第一层的浅拷贝
   function simpleCopy(obj1) {var obj2 = Array.isArray(obj1) ? [] : {};
      for (let i in obj1) {obj2[i] = obj1[i];
     }
      return obj2;
   }
   var obj1 = {
      a: 1,
      b: 2,
      c: {d: 3}
   }
   var obj2 = simpleCopy(obj1);
   obj2.a = 3;
   obj2.c.d = 4;
   alert(obj1.a); // 1
   alert(obj2.a); // 3
   alert(obj1.c.d); // 4
   alert(obj2.c.d); // 4

2. Object.assign()

   var obj = {
       a: 1,
       b: 2
   }
   var obj1 = Object.assign({},obj);
   boj1.a = 3;
   console.log(obj.a) // 3

3. 直接赋值

   let a=[0,1,2,3,4],
       b=a;
   console.log(a===b);
   a[0]=1;
   console.log(a,b);

深拷贝的实现

采用递归去拷贝所有层级属性

function deepClone(obj){let objClone = Array.isArray(obj)?[]:{};
    if(obj && typeof obj==="object"){for(key in obj){if(obj.hasOwnProperty(key)){
                // 判断 ojb 子元素是否为对象，如果是，递归复制
                if(obj[key]&&typeof obj[key] ==="object"){objClone[key] = deepClone(obj[key]);
                }else{
                    // 如果不是，简单复制
                    objClone[key] = obj[key];
                }
            }
        }
    }
    return objClone;
}    
let a=[1,2,3,4],
    b=deepClone(a);
a[0]=2;
console.log(a,b);

缺陷：当遇到两个互相引用的对象，会出现死循环，为了避免相互引用的对象导致死循环，应该在遍历的时候判断是否相互引用对象，如果是则退出循环

通过 JSON 对象来实现拷贝（无法实现对对象中方法的深拷贝，会显示为 undefined）

function deepClone2(obj) {var _obj = JSON.stringify(obj),
    objClone = JSON.parse(_obj);
  return objClone;
}

通过 jQuery 的 extend 方法实现深拷贝

var array = [1,2,3,4];
var newArray = $.extend(true,[],array); // true 为深拷贝，false 为浅拷贝 

lodash 函数库实现深拷贝

let result = _.cloneDeep(test)

Reflect 法

// 代理法
function deepClone(obj) {if (!isObject(obj)) {throw new Error('obj 不是一个对象！')
    }

    let isArray = Array.isArray(obj)
    let cloneObj = isArray ? [...obj] : {...obj}
    Reflect.ownKeys(cloneObj).forEach(key => {cloneObj[key] = isObject(obj[key]) ? deepClone(obj[key]) : obj[key]
    })

    return cloneObj
}