浅谈深拷贝和浅拷贝

亦凉 2023-02-21 09:04 4阅读 0赞

浅谈深拷贝和浅拷贝  
深拷贝和浅拷贝的区别  
为什么要使用深拷贝？  
深拷贝的要求程度  
怎么检验深拷贝成功  
只对第一层级做拷贝  
拷贝所有层级  
存在大量深拷贝需求的代码——immutable提供的解决方案  
正文

前言： 最开始意识到深拷贝的重要性是在我使用redux的时候（react + redux）， redux的机制要求在reducer中必须返回一个新的对象，而不能对原来的对象做改动，事实上，当时我当然不会主动犯这个错误，但很多时候，一不小心可能就会修改了原来的对象，例如：var newObj = obj; newObj.xxx = xxx  实际上，这个时候newObj和obj两个引用指向的是同一个对象，我修改了newObj，实际上也就等同于修改了obj，这，就是我和深浅拷贝的第一次相遇。

深拷贝和浅拷贝的区别  
1.浅拷贝： 将原对象或原数组的引用直接赋给新对象，新数组，新对象／数组只是原对象的一个引用

2.深拷贝： 创建一个新的对象和数组，将原对象的各项属性的“值”（数组的所有元素）拷贝过来，是“值”而不是“引用”

为什么要使用深拷贝？

我们希望在改变新的数组（对象）的时候，不改变原数组（对象）

深拷贝的要求程度

我们在使用深拷贝的时候，一定要弄清楚我们对深拷贝的要求程度：是仅“深”拷贝第一层级的对象属性或数组元素，还是递归拷贝所有层级的对象属性和数组元素？

怎么检验深拷贝成功

改变任意一个新对象/数组中的属性/元素,     都不改变原对象/数组

只对第一层级做拷贝  
深拷贝数组（只拷贝第一级数组元素）

直接遍历  
var array = \[1, 2, 3, 4\];  
function copy (array) \{  
   let newArray = \[\]  
   for(let item of array) \{  
      newArray.push(item);  
   \}  
   return  newArray;  
\}  
var copyArray = copy(array);  
copyArray\[0\] = 100;  
console.log(array); // \[1, 2, 3, 4\]  
console.log(copyArray); // \[100, 2, 3, 4\]  
该方法不做解释（逃...）

2. slice()

var array = \[1, 2, 3, 4\];  
var copyArray = array.slice();  
copyArray\[0\] = 100;  
console.log(array); // \[1, 2, 3, 4\]  
console.log(copyArray); // \[100, 2, 3, 4\]  
slice() 方法返回一个从已有的数组中截取一部分元素片段组成的新数组（不改变原来的数组！）

用法：array.slice(start,end) start表示是起始元素的下标，　end表示的是终止元素的下标

当slice()不带任何参数的时候，默认返回一个长度和原数组相同的新数组

3. concat()

var array = \[1, 2, 3, 4\];  
var copyArray = array.concat();  
copyArray\[0\] = 100;  
console.log(array); // \[1, 2, 3, 4\]  
console.log(copyArray); // \[100, 2, 3, 4\]  
concat() 方法用于连接两个或多个数组。( 该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。)

用法：array.concat(array1,array2,......,arrayN)

因为我们上面调用concat的时候没有带上参数，所以var copyArray = array.concat();实际上相当于var copyArray = array.concat(\[\]);也即把返回数组和一个空数组合并后返回

但是，事情当然不会这么简单，我上面的标题是 “深拷贝数组（只拷贝第一级数组元素）”，这里说的意思是对于一级数组元素是基本类型变量（如number,String,boolean）的简单数组, 上面这三种拷贝方式都能成功，但对第一级数组元素是对象或者数组等引用类型变量的数组，上面的三种方式都将失效，例如：

1.直接遍历

2.ES6的Object.assign

用法： Object.assign(target, source1, source2);  所以 copyObj = Object.assign(\{\}, obj);  这段代码将会把obj中的一级属性都拷贝到 ｛｝中，然后将其返回赋给copyObj

3.ES6扩展运算符：

var obj = \{  
    name: '彭湖湾',  
    job: '学生'  
\}  
var copyObj = \{ ...obj \}  
copyObj.name = '我才不叫彭湖湾呢！ 哼  (。・\`ω´・)'  
console.log(obj.name) //   彭湖湾  
console.log(copyObj.name)  // 我才不叫彭湖湾呢！ 哼  (。・\`ω´・)  
扩展运算符（...）用于取出参数对象的所有可遍历属性，拷贝到当前对象之中

对多层嵌套对象，很遗憾，上面三种方法，都会失败：

1.不仅拷贝第一层级，还能够拷贝数组或对象所有层级的各项值

2. 不是单独针对数组或对象，而是能够通用于数组，对象和其他复杂的JSON形式的对象

请看下面：

下面这一招可谓是“一招鲜，吃遍天”

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

JSON.stringify() 方法是将一个JavaScript值(对象或者数组)转换为一个 JSON字符串--(序列化）

序列化的缺点：

不支持基本数据类型的undefined，序列化后将其省略  
不支持函数  
Nan,Infinity序列化的结果是null  
能用大招杀的就不要用q杀嘛！！

2.手动写递归

你说啥？ 你说上面的那种方法太无脑,  一定要自己写一段递归才有做技术的感觉？ OK成全你！

上述代码中还隐藏这两个知识点：

（1）obj == null 为何不是 obj === null?

obj==null =>obj为null 或者 obj 为undefined，即obj===null || obj === undefined，因为null == undefined,这样写能默认处理两种情况，obj===null ，成立前提只有obj是null

（2）怎样判断一个对象是不是数组？

先上方法（确定的方法有两种）

根据对象的class属性来判断，跨原型链调用toString()方法。  Object. prototype.toString.call(obj)===\[ object Array\]  
Array.isArray直接判断   Array. isArray(obj)。  
补充：

推荐文章：为什么用Object.prototype.toString.call(obj)检测对象类型

toString为Object的原型方法,返回一个用来描述该对象的字符串，所以可以调用对象原型方法toString()来探明对象的信息。  
那么原型方法怎么调用呢，利用call，将其this指向需要判断的对象, 就可以用toString()方法了。  
let arr=\[1,2,3\];  
console.log(Array.prototype.hasOwnProperty("toString"));//true  
console.log(arr.toString());//1,2,3 arr作为对象Object的实例，重写了toString()方法。  
delete Array.prototype.toString;//delete操作符可以删除实例属性  
console.log(Array.prototype.hasOwnProperty("toString"));//false  
console.log(arr.toString());//"\[object Array\]"   
// 由于删除了实例对象中的toString()方法，找不到，顺着原型链往上走，就调用了对象Object的方法，返回的结果就和Array.prototype.toString(arr）一样的。  
根据构造函数来判断 instanceof 操作符可以来表示实例是否属于某个构造函数创建的。  
这种方法有一个问题，就是验证不够严格。 即使对象创建时不是使用数组创建的，但是只要原型链上有数组类型，也认为是数组,亦或者，即便创建时是数组创建，但其原型上有对象类型，便不再被认为是数组。

推荐文章

（3）for...in 和for...of，forEach的区别，for...in用于对象复制时需要注意什么？

for... in特点

遍历对象返回的对象的key值,遍历数组返回的数组的下标(key)。

for ... in 会遍历原型上的属性值

遍历返回数据是乱序

总结一句: for in 循环特别适合遍历对象。  
for... of特点

for of遍历的只是数组内的元素，而不包括数组的原型属性method和索引name

for ... in 会遍历原型上的属性值

遍历返回数据是乱序

for of 不同与 forEach, 它可以与 break、continue和return 配合使用,也就是说 for of 循环可以随时退出循环。

总结一句: for of 比较适合遍历数组，及其他具有遍历器的集合  
forEach特点

使用foreach遍历数组的话，使用break不能中断循环，使用return也不能返回到外层函数。forEach与break和return 不搭

forEach()无法在所有元素都传递给调用的函数之前终止遍历

for…in循环可应用于对象的复制，不过其有一个缺点，就是会从原型属性里继承prototype()属性。

例如：

let array = \[1,2,3,4,5\]   
Array.prototype.age = 13；  
var result = \[\];   
for（let i in array）\{   
    result.push(array\[i\]);   
\}   
alert(result.join(“,”));   
result返回结果【1,2,3,4,5,13】   
如何避免从原型属性里继承prototype()属性，这里使用hasOwnProperty(name)，该函数指示一个对象自身（不包括原型链）是否具有指定名称的属性。如果有返回true，如果没有返回false。

let array = \[1,2,3,4,5\]   
Array.prototype.age = 13；   
var result = \[\];   
for（let i in array）\{   
if(array.hasOwnProperty(i))\{   
    result.push(array\[i\]);   
\}   
alert(result.join(“,”));   
\}   
result返回结果【1,2,3,4,5】  
所以上面的深拷贝代码应优化为如下：

immutable的作用：

通过immutable引入的一套API，实现：

1.在改变新的数组（对象）的时候，不改变原数组（对象）

2.在大量深拷贝操作中显著地减少性能消耗

先睹为快：

const \{ Map \} = require('immutable')  
const map1 = Map(\{ a: 1, b: 2, c: 3 \})  
const map2 = map1.set('b', 50)  
map1.get('b') // 2  
map2.get('b') // 50