在写 JavaScript 程序的时候经常看到一些奇妙的代码被用来处理对象的拷贝,这篇文章会枚举笔者看到的一些作法,并提供较好的作法给大家参考。
在这篇文章开始之前,先来讲一下为什么「拷贝对象」这个看似基本且简单的事情会有问题好了。
首先看看以下的代码:
let a = 0;
let b = a;
a = 1;
console.log(b);
以上程序,将 0 指派给变量 a 保存,然后又将变量 a 的值指派给变量 b 保存,之后指派 1 给变量 a 保存,此时的变量 b 所保存的值是什么?很明显,就是变量 a 一开始的 0。
那么将以上程序改成以下这样:
let a = [0];
let b = a;
a = [1];
console.log(b);
此时的变量 b 会是什么呢?相信绝大多数的人都能回答得出来,就是变量 a 一开始的 [0]。
再将以上程序改成以下这样:
let a = [0];
let b = a;
a[0] = 1;
console.log(b);
以上程序的第四行,将变量 a 所保存的数组的索引 0 的位置的元素值改成 1,变量 b 会有变化吗?会,变量 b 此时是 [1]。所以变量 a 和变量 b 其实是一样的数组对象啰……?没错,所以不管是去改 a 还是改 b 的元素,都会影响到对方。
所以现在我们就遭遇到了第一个困难:要怎么拷贝数组对象,让变量 a 和变量 b 是不一样的数组对象,使它们不会互相影响呢?
相信聪明的读者很快就会想到,我们可以先指派一个空数组给变量 b,再把变量 a 的数组元素一个一个放进变量 b 的数组,放完之后不就是两个没有关联的数组了吗?程序如下:
let a = [0];
let b = [];
for (const e of a) {
b.push(e);
}
a[0] = 1;
console.log(b);
以上程序,最终,变量 b 依然还是 [0]。我们成功实现了数组的拷贝!
甚至我们可以利用 ... 蔓延语法(Spread Syntax)来快速填入元素,如下:
let a = [0];
let b = [...a];
a[0] = 1;
console.log(b);
我们再来看看下面的代码:
let a = [[0]];
let b = [];
for (const e of a) {
b.push(e);
}
a[0][0] = 1;
console.log(b);
以上程序中,变量 a 和变量 b 已经利用拷贝数组的作法使它们成为不同的数组,然而最终,变量 b 还是变成 [[1]] 了。这是因为我们虽然拷贝了最外层的数组,但里面的元素却没有跟着被拷贝。此时的 a[0] 和 b[0] 其实是一样的数组对象。
所以现在我们就遭遇到了第二个困难:要怎么拷贝数组对象,让里面就算有对象类型(Object)的元素,变量 a 和变量 b 依然还是不一样的数组对象,不会互相影响呢?
事实上,我们刚才实作出来的拷贝数组的程序属于浅拷贝(shallow copy),创建了新的内存空间,只拷贝了最外层的值,若最外层的值是对象的参考,则同样会指到相同的对象。要做到完全拷贝,需要一一去看每层的值,属于深拷贝(deep copy)。
深拷贝
利用串行化再反串行化的方式可以轻易地做到深拷贝。如下:
const a = [[0]];
const b = JSON.parse(JSON.stringify(a));
a[0][0] = 1;
console.log(b);
以上方式虽然实作起来最简单,但因要串行化成 JSON 格式的字符串而导致性能会随着数据量愈多而显著变差,且只能支持 JSON 有的类型,像是 NaN、Infinity、undefined 和 Function 等就无法拷贝成功(NaN、Infinity 会变成 null,其它 JSON 不支持的类型则会被忽略)。JSON.stringify 也不支持有循环参考的数据。
如果 JavaScript 程序只会运行在 Node.js 环境上,倒是可以改写成以下这样来支持更多的类型(function、symbol 不能被拷贝,会抛出错误),性能不会太差,可以支持有循环参考的数据。
import v8 from "node:v8";
const a = [[0]];
const b = v8.deserialize(v8.serialize(a));
a[0][0] = 1;
console.log(b);
在 Node.js 17 之后的版本以及较新的网页浏览器中,可以改用 structuredClone 函数:
const a = [[0]];
const b = structuredClone(a);
a[0][0] = 1;
console.log(b);
不过不管是什么场合,都不太建议用串行化再反串行化的方式来做拷贝。最好的办法还是根据拷贝需求,来撰写我们需要的程序。
如果是使用 TypeScript,还能撰写相对安全且能重复使用的函数,因为我们可以利用 TypeScript 的类型检查机制来确保被传入函数的参数的类型是我们预期的。如下:
const cloneArrayOfArraysOfNumbers = (array: (number[])[]) => {
return array.map((e) => [...e]);
};
const a = [[0]];
const b = cloneArrayOfArraysOfNumbers(a);
a[0][0] = 1;
console.log(b);
如果您还是需要一个最通用且支持所有类型的深拷贝函数,也不用自己造车,直接使用 Lodash 提供的 cloneDeep 函数即可。不过这个作法甚至会比用 JSON 做串行化再反串行化还要更慢。程序如下:
import { cloneDeep } from "lodash";
const a = [[0]];
const b = cloneDeep(a);
a[0][0] = 1;
console.log(b);
即便是 Lodash 提供的 cloneDeep 函数也还是不能拷贝对象的属性的特性(即 writable、enumerable 等 Property Descriptor 内的选项)。
至于在网络上您可能会搜索到其它类似以下的深拷贝函数,笔者就不建议使用了,因为性能不会比 Lodash 提供的 cloneDeep 函数好,可能还有一些潜在的问题。
// 不要用,这是烂Code!
const cloneDeep = (obj, cache = new WeakMap()) => {
switch (typeof obj) {
case "object":
if (obj === null) {
return null;
} else if (cache.has(obj)) {
return cache.get(obj);
} else {
const newObj = new obj.constructor();
cache.set(obj, newObj);
[...Object.getOwnPropertyNames(obj), ...Object.getOwnPropertySymbols(obj)].forEach(key => {
newObj[key] = cloneDeep(obj[key], cache);
});
return newObj;
}
default:
return obj;
}
};
如果您只需要简单支持 number、string 等基本类型,以及常用的 Date 和 RegExp 等不会被修改的对象(以下函数不会拷贝它们,而是直接共用同一个对象)所组合而成的数组或是对象结构,可以试试以下的函数,再依照您自己的需求去修改(例如把 Date 和 RegExp 移除,不去判断它们;或是增加更多不会被修改的对象的判别)。
const cloneDeep = (obj, cache = new WeakMap()) => {
switch (typeof obj) {
case "object":
if (obj === null || obj instanceof Date || obj instanceof RegExp) {
return obj;
} else if (cache.has(obj)) {
return cache.get(obj);
} else {
let newObj;
if (Array.isArray(obj)) {
newObj = new Array(obj.length);
cache.set(obj, newObj);
obj.forEach((value, index) => {
newObj[index] = cloneDeep(value, cache);
});
} else {
newObj = {};
cache.set(obj, newObj);
for (const key of Object.keys(obj)) {
newObj[key] = cloneDeep(obj[key], cache);
}
}
return newObj;
}
default:
return obj;
}
};
以下是将以上程序移除掉 WeakMap 后的版本,运行速度会快一些,但不支持循环参考。
const cloneDeep = (obj) => {
switch (typeof obj) {
case "object":
if (obj === null || obj instanceof Date || obj instanceof RegExp) {
return obj;
} else if (Array.isArray(obj)) {
return obj.map((e) => cloneDeep(e));
} else {
const newObj = {};
for (const key of Object.keys(obj)) {
newObj[key] = cloneDeep(obj[key]);
}
return newObj;
}
default:
return obj;
}
};
