在写 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;
    }
};