javascript（JS） --- 浅拷贝和深拷贝 --- 带你深入手写一个深拷贝函数

前端鳄鱼崽
94 阅读9分钟

一起养成写作习惯！这是我参与「掘金日新计划 · 4 月更文挑战」的第12天，点击查看活动详情。

浅拷贝与深拷贝

  • 浅拷贝是创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值，如果属性是引用类型，拷贝的就是内存地址 ，所以如果其中一个对象改变了这个地址，就会影响到另一个对象。
  • 深拷贝是将一个对象从内存中完整的拷贝一份出来,从堆内存中开辟一个新的区域存放新对象,且修改新对象不会影响原对象。

赋值和深/浅拷贝的区别

这三者的区别如下，不过比较的前提都是针对引用类型：

  • 当我们把一个对象赋值给一个新的变量时，赋的其实是该对象的在栈中的地址，而不是堆中的数据。也就是两个对象指向的是同一个存储空间，无论哪个对象发生改变，其实都是改变的存储空间的内容，因此，两个对象是联动的。
  • 浅拷贝：重新在堆中创建内存，拷贝前后对象的基本数据类型互不影响，但拷贝前后对象的引用类型因共享同一块内存，会相互影响。
  • 深拷贝：从堆内存中开辟一个新的区域存放新对象，对对象中的子对象进行递归拷贝,拷贝前后的两个对象互不影响。

浅拷贝的实现方式

1.Object.assign()

Object.assign() 方法可以把任意多个的源对象自身的可枚举属性拷贝给目标对象，然后返回目标对象。

let obj1 = { person: {name: "kobe", age: 41},sports:'basketball' };
let obj2 = Object.assign({}, obj1);
obj2.person.name = "wade";
obj2.sports = 'football'
console.log(obj1); // { person: { name: 'wade', age: 41 }, sports: 'basketball' }

2.Object.create()

Object.create(proto, [descriptors])—— 利用给定的 proto 作为 [[Prototype]] 和可选的属性描述来创建一个空对象。

let obj = {name:'zs',age:18,function(){},job:{person:'zhang'}}
let clone = Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
clone.job.person = 'li'
console.log(obj); // person:'li'

3.Object.defineProperties()

Object.defineProperties(obj, descriptors) 该方法接受一个目标obj参数，和要应用的属性描述符对象。

let obj = {name:'zs',age:18,function(){},job:{person:'zhang'}}
let clone = Object.defineProperties({}, Object.getOwnPropertyDescriptors(obj));
clone.job.person = 'li'
console.log(obj);  // person:'li'

4.函数库lodash的_.clone方法

该函数库也有提供_.clone用来做 Shallow Copy,后面我们会再介绍利用这个库实现深拷贝。

var _ = require('lodash');
var obj1 = {
    a: 1,
    b: { f: { g: 1 } },
    c: [1, 2, 3]
};
var obj2 = _.clone(obj1);
console.log(obj1.b.f === obj2.b.f);// true

5.展开运算符...

展开运算符是一个 es6 / es2015特性，它提供了一种非常方便的方式来执行浅拷贝，这与 Object.assign ()的功能相同。

let obj1 = { name: 'Kobe', address:{x:100,y:100}}
let obj2= {... obj1}
obj1.address.x = 200;
obj1.name = 'wade'
console.log('obj2',obj2) // obj2 { name: 'Kobe', address: { x: 200, y: 100 } }

6.Array.prototype.concat()

let arr = [1, 3, {
    username: 'kobe'
    }];
let arr2 = arr.concat();    
arr2[2].username = 'wade';
console.log(arr); //[ 1, 3, { username: 'wade' } ]

5.Array.prototype.slice()

let arr = [1, 3, {
    username: ' kobe'
    }];
let arr3 = arr.slice();
arr3[2].username = 'wade'
console.log(arr); // [ 1, 3, { username: 'wade' } ]

深拷贝的实现方式

1.JSON.parse(JSON.stringify())

这也是利用JSON.stringify将对象转成JSON字符串，再用JSON.parse把字符串解析成对象，一去一来，新的对象产生了，而且对象会开辟新的栈，实现深拷贝。

let obj = {name:'孙悟空',job:{person:'李四'},func:function(){}}
let clone = JSON.parse(JSON.stringify(obj))
clone.job.person = '张三'
console.log(obj); // {name: "孙悟空", job: {person:'李四'}, func: ƒ}
console.log(clone); // {name: "孙悟空", job: {person:'张三'}}

可以看到，clone的对象更改了，并没有影响到原对象obj：

image-20220225180932395

这种方法虽然可以实现数组或对象深拷贝,但不能处理函数和正则，因为这两者基于JSON.stringify和JSON.parse处理后，得到的正则就不再是正则（变为空对象），得到的函数就不再是函数（变为null）了。

比如下面的例子：

image-20220225181301783

2.函数库lodash的_.cloneDeep方法

该函数库也有提供_.cloneDeep用来做 Deep Copy

var _ = require('lodash');
var obj1 = {
    a: 1,
    b: { f: { g: 1 } },
    c: [1, 2, 3]
};
var obj2 = _.cloneDeep(obj1);
console.log(obj1.b.f === obj2.b.f);// false

3.jQuery.extend()方法

jquery 有提供一個$.extend可以用来做 Deep Copy

$.extend(deepCopy, target, object1, [objectN])//第一个参数为true,就是深拷贝

var $ = require('jquery');
var obj1 = {
    a: 1,
    b: { f: { g: 1 } },
    c: [1, 2, 3]
};
var obj2 = $.extend(true, {}, obj1);
console.log(obj1.b.f === obj2.b.f); // false

4.手写递归方法

前置知识：weakMap（弱映射）ES6中新增的一种数据结构，它不同于Map（强映射） WeakMap 的键必须是对象，并且当它的键值引用消失后，它会被垃圾回收掉，具体详情了解：WeakMap，WeakSet

递归方法实现深度克隆原理：遍历对象、数组直到里边都是基本数据类型，然后再去复制，就是深度拷贝。

有种特殊情况需注意就是对象存在循环引用的情况，即对象的属性直接的引用了自身的情况，解决循环引用问题，我们可以额外开辟一个存储空间，来存储当前对象和拷贝对象的对应关系，当需要拷贝当前对象时，先去存储空间中找，有没有拷贝过这个对象，如果有的话直接返回，如果没有的话继续拷贝，这样就巧妙化解的循环引用的问题。

function deepClone(obj, hash = new WeakMap()) {
  if (obj == null) return obj; // 如果是null或者undefined我就不进行拷贝操作
  if (obj instanceof Date) return new Date(obj);  //  返回Date与正则的函数
  if (obj instanceof RegExp) return new RegExp(obj);
  // 可能是对象或者普通的值  如果是函数的话是不需要深拷贝
  if (typeof obj !== "object") return obj;
  // 是对象的话就要进行深拷贝
  if (hash.get(obj)) return hash.get(obj);  // 如果是循环引用则直接返回保存的值，防止陷入死循环
  let cloneObj = new obj.constructor();  	// 找到的是所属类原型上的constructor,而原型上的 constructor指向的是当前类本身
	// 保存循环引用的obj
  hash.set(obj, cloneObj);
  for (let key in obj) {
		// 判断过滤继承而来的属性
    if (obj.hasOwnProperty(key)) {
      // 实现一个递归拷贝
      cloneObj[key] = deepClone(obj[key], hash);
    }
  }
  return cloneObj;
}
let obj = [1,2,{person:'孙悟空'},function(){}]
let d = deepClone(obj);
obj[2].person = '白骨精';
console.log(d);
console.log(obj);

image-20220225191149276

可以看到该拷贝对象也不再是简单的引用地址，而是创建的一个新的对象，并且即使循环引用原对象，也不会造成死循环：

let obj = [1,2,{person:'孙悟空'},function(){}]
obj.rec = obj // 对象存在循环引用的情况
let d = deepClone(obj);
console.log(d);

image-20220225191500912

但是这样的利用 for in obj 的方式拷贝的obj存在一个弊端，对于不可遍历的Symbol 类型的数据将不会复制

let obj = {name:'zs',age:18,[Symbol('2')]:'sss'}
let clone = deepClone(obj)
console.log(clone);  // {name: "zs", age: 18, Symbol(2): "sss"}
console.log(obj);   // {name: "zs", age: 18}

image-20220225192337769

为了解决这个问题，我们可以再进入 for in 判断时先判断obj中有没有Symbol类型的数据，可以有以下两个方法：

方法一：`Object.getOwnPropertySymbols(…)`  // 查找obj里有无Symbol类型 并返回一个 symbol 类型的数组

方法二：`Reflect.ownKeys(…)`  //  Reflect.ownKeys() 获取所有的键值，同时包括 Symbol

方法一：Object.getOwnPropertySymbols(…)

function deepClone(obj, hash = new WeakMap()) {
      if (obj == null) return obj; // 如果是null或者undefined我就不进行拷贝操作
      if (obj instanceof Date) return new Date(obj);  //  返回Date与正则的函数
      if (obj instanceof RegExp) return new RegExp(obj);
      // 可能是对象或者普通的值  如果是函数的话是不需要深拷贝
      if (typeof obj !== "object") return obj;
      // 是对象的话就要进行深拷贝
      if (hash.get(obj)) return hash.get(obj);  // 如果是循环引用则直接返回保存的值，防止陷入死循环
      let cloneObj = new obj.constructor();  	// 找到的是所属类原型上的constructor,而原型上的 constructor指向的是当前类本身
        // 保存循环引用的obj
      hash.set(obj, cloneObj);
    /*--------------------------------------------------添加的内容---------------------------------------------------------------*/
        // 判读有没有symbol类型的
         let symbolKey = Object.getOwnPropertySymbols(obj)
         if(symbolKey.length !== 0){
         	symbolKey.forEach(item=>{
         		cloneObj[item] = deepClone(obj[item],hash)
         	})
         }
    /*--------------------------------------------------添加的内容---------------------------------------------------------------*/
      for (let key in obj) {
            // 判断过滤继承而来的属性
        if (obj.hasOwnProperty(key)) {
          // 实现一个递归拷贝
          cloneObj[key] = deepClone(obj[key], hash);
        }
      }
      return cloneObj;
}

方法二：Reflect.ownKeys(…)

function deepClone(obj, hash = new WeakMap()) {
  if (obj == null) return obj; // 如果是null或者undefined我就不进行拷贝操作
  if (obj instanceof Date) return new Date(obj);  //  返回Date与正则的函数
  if (obj instanceof RegExp) return new RegExp(obj);
  // 可能是对象或者普通的值  如果是函数的话是不需要深拷贝
  if (typeof obj !== "object") return obj;
  // 是对象的话就要进行深拷贝
  if (hash.get(obj)) return hash.get(obj);  // 如果是循环引用则直接返回保存的值，防止陷入死循环
  let cloneObj = new obj.constructor();  	// 找到的是所属类原型上的constructor,而原型上的 constructor指向的是当前类本身
	// 保存循环引用的obj
  hash.set(obj, cloneObj);
      /*--------------------------------------------------添加的内容---------------------------------------------------------------*/
	Reflect.ownKeys(obj).forEach(item=>{
		cloneObj[item] = deepClone(obj[item],hash)
	}) 
      /*--------------------------------------------------添加的内容---------------------------------------------------------------*/
  return cloneObj;
}

总结：手写深拷贝终极版

方法一：Reflect.ownKeys(…)

Reflect.ownKeys() 获取所有的键值，同时包括 Symbol 类型

function deepClone(obj, hash = new WeakMap()) {
  if (obj == null) return obj; // 如果是null或者undefined我就不进行拷贝操作
  if (obj instanceof Date) return new Date(obj);  //  返回Date与正则的函数
  if (obj instanceof RegExp) return new RegExp(obj);
  // 可能是对象或者普通的值  如果是函数的话是不需要深拷贝
  if (typeof obj !== "object") return obj;
  // 是对象的话就要进行深拷贝
  if (hash.get(obj)) return hash.get(obj);  // 如果是循环引用则直接返回保存的值，防止陷入死循环
  let cloneObj = new obj.constructor();  	// 找到的是所属类原型上的constructor,而原型上的 constructor指向的是当前类本身
	// 保存循环引用的obj
  hash.set(obj, cloneObj);
      /*--------------------------------------------------添加的内容---------------------------------------------------------------*/
	Reflect.ownKeys(obj).forEach(item=>{
		cloneObj[item] = deepClone(obj[item],hash)
	}) 
      /*--------------------------------------------------添加的内容---------------------------------------------------------------*/
  return cloneObj;
}
let obj = {name:'zs',age:18,[Symbol('2')]:'sss',func:function(){}}
let clone = deepClone(obj)
clone.name = '孙悟空'
console.log(obj);
console.log(clone);

image-20220225193629660

方法二：Object.getOwnPropertySymbols(…)

查找obj里有无Symbol类型 并返回一个 symbol 类型的数组

function deepClone(obj, hash = new WeakMap()) {
      if (obj == null) return obj; // 如果是null或者undefined我就不进行拷贝操作
      if (obj instanceof Date) return new Date(obj);  //  返回Date与正则的函数
      if (obj instanceof RegExp) return new RegExp(obj);
      // 可能是对象或者普通的值  如果是函数的话是不需要深拷贝
      if (typeof obj !== "object") return obj;
      // 是对象的话就要进行深拷贝
      if (hash.get(obj)) return hash.get(obj);  // 如果是循环引用则直接返回保存的值，防止陷入死循环
      let cloneObj = new obj.constructor();  	// 找到的是所属类原型上的constructor,而原型上的 constructor指向的是当前类本身
        // 保存循环引用的obj
      hash.set(obj, cloneObj);
    /*--------------------------------------------------添加的内容---------------------------------------------------------------*/
        // 判读有没有symbol类型的
         let symbolKey = Object.getOwnPropertySymbols(obj)
         if(symbolKey.length !== 0){
         	symbolKey.forEach(item=>{
         		cloneObj[item] = deepClone(obj[item],hash)
         	})
         }
    /*--------------------------------------------------添加的内容---------------------------------------------------------------*/
      for (let key in obj) {
            // 判断过滤继承而来的属性
        if (obj.hasOwnProperty(key)) {
          // 实现一个递归拷贝
          cloneObj[key] = deepClone(obj[key], hash);
        }
      }
      return cloneObj;
}
let obj = [1,2,{person:'孙悟空'},function(){},Symbol('22')]
obj.rec = obj // 对象存在循环引用的情况
let d = deepClone(obj);
d[2].person = '白骨精'
console.log(obj);
console.log(d);

image-20220225194050332

avatar
文章
阅读
粉丝