当前位置:   article > 正文

对JS浅拷贝与深拷贝的一些理解_obejct.assign和clonedeep

obejct.assign和clonedeep
  • 浅拷贝与深拷贝

  • 浅拷贝是创建一个新对象,这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型,拷贝的就是基本类型的值,如果属性是引用类型(对象、数组),拷贝的就是内存地址 ,所以如果其中一个对象改变了这个地址,就会影响到另一个对象

  • 深拷贝是将一个对象从内存中完整的拷贝一份出来,从堆内存中开辟一个新的区域存放新对象,且修改新对象不会影响原对象

总而言之,浅拷贝只复制指向某个对象的指针,而不复制对象本身,新旧对象还是共享同一块内存。但深拷贝会另外创造一个一模一样的对象,新对象跟原对象不共享内存,修改新对象不会改到原对象。

赋值(=)和深/浅拷贝的区别

这三者的区别如下,不过比较的前提都是针对引用类型(对象、数组)

  • 当我们把一个对象赋值给一个新的变量时,赋的其实是该对象的在栈中的地址,而不是堆中的数据。也就是两个对象指向的是同一个存储空间,无论哪个对象发生改变,其实都是改变的存储空间的内容,因此,两个对象是联动的。

  • 浅拷贝:重新在堆中创建内存,拷贝前后对象的基本数据类型互不影响,但拷贝前后对象的引用类型因共享同一块内存,会相互影响。

  • 深拷贝:从堆内存中开辟一个新的区域存放新对象,对对象中的子对象进行递归拷贝,拷贝前后的两个对象互不影响。

注意!这里的赋值是指用对象/数组赋值,

浅拷贝的实现方式 

1.Object.assign()

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

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

这里可以看到,改变对象的基本类型,原对象所对应的基本类型是不会改变的,而改变引用类型里面的任何值,原对象也会跟着改变。

Object.assign()的写法:  newObj = Object.assign( {}, oldObj )或者可以写成 Object.assign(newObj , oldObj ) 。原理就是把旧对象赋值给一个空对象,再让空对象赋值给新对象

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

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

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

3.展开运算符...

展开运算符是一个 es6 特性,它提供了一种非常方便的方式来执行浅拷贝,这与 Object.assign ()的功能相同。同样可以用来浅拷贝数组。原理就是将对象或数组中可以列举的属性展开拷贝给新对象

写法:newObj = {... oldObj}  ,同时可以用于对象拼接:newObj = {... oldObj1 , ... oldObj2} ,

newArray = [... oldArray]

  1. let obj1 = { name: 'Kobe', address:{x:100,y:100}}
  2. let obj2= {... obj1}
  3. obj1.address.x = 200;
  4. obj1.name = 'wade'
  5. console.log('obj2',obj2) // obj2 { name: 'Kobe', address: { x: 200, y: 100 } }
  1. //如果数组只有基本类型,改变基本类型,或单纯改变哪一项(包括对象),则原数组不会改变
  2. let array = [0,1,2]
  3. let array2 = [...array]
  4. array2[0] = '00'
  5. console.log(array2); //['00', 1, 2]
  6. console.log(array); //[0, 1, 2]
  7. let array = [{ name1: '11'},{ name2: '22'}]
  8. let array2 = [...array]
  9. array2[0] = { name1: '00'} //****这里不算是改变了,相当于重新赋值,相当于重新分配内存
  10. console.log(array2); // [{ name1: '00'},{ name2: '22'}]
  11. console.log(array); // [{ name1: '11'},{ name2: '22'}]
  12. //若改变某一项(对象)里面的值,则原数组也会跟着改变
  13. let array = [{ name1: '11'},{ name2: '22'}]
  14. let array2 = [...array]
  15. array2[0].name1 = '00'
  16. console.log(array2); // [{ name1: '00'},{ name2: '22'}]
  17. console.log(array); // [{ name1: '00'},{ name2: '22'}]

4.Array.prototype.concat()

concat() 方法用于连接两个或多个数组。

concat() 方法不会更改现有数组,而是返回一个新数组,其中包含已连接数组的值。

array1.concat(array2, array3, ..., arrayX)

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

5.Array.prototype.slice()​​​​​​​

slice() 方法以新的数组对象,返回数组中被选中的元素。

slice() 方法选择从给定的 start 参数开始的元素,并在给定的 end 参数处结束,但不包括。

注释:slice() 方法不会改变原始数组。

start

可选。整数,指定从哪里开始选择(第一个元素的索引为 0)。

使用负数从数组的末尾进行选择。如果省略,则类似于 "0"。

end

可选。整数,指定结束选择的位置。

如果省略,将选择从开始位置到数组末尾的所有元素。使用负数从数组末尾进行选择。

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

深拷贝的实现方式

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

  1. let arr = [1, 3, {
  2. username: ' kobe'
  3. }];
  4. let arr4 = JSON.parse(JSON.stringify(arr));
  5. arr4[2].username = 'duncan';
  6. console.log(arr, arr4)

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

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

比如下面的例子:

  1. let arr = [1, 3, {
  2. username: ' kobe'
  3. },function(){}];
  4. let arr4 = JSON.parse(JSON.stringify(arr));
  5. arr4[2].username = 'duncan';
  6. console.log(arr, arr4)

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

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

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


 

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/你好赵伟/article/detail/68289
推荐阅读
相关标签
  

闽ICP备14008679号