JavaScript API性能对比系列二：深拷贝和浅拷贝性能对比

最新推荐文章于 2025-06-04 21:19:19 发布
原创 最新推荐文章于 2025-06-04 21:19:19 发布 · 1.5k 阅读 · 9 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#javascript #开发语言 #ecmascript

以下是测试性能的环境

CPUAMD Ryzen 9 5900HX with Radeon Graphics 八核
操作系统Windows 11 家庭中文版 (64位)
内存16GB(3200 MHz / 3200 MHz)
Nodejsv18.16.0

测试一：元素全是基础类型的数组

测试代码

import {cloneDeep, clone} from "lodash-es";

const time = 1000 * 10000;
const val = 'abcdefghijklmnopqrstuvwxyz';
const arr = new Array(time).fill(val);

let copyArr = [];
console.time('【深拷贝】JSON.parse');
copyArr = JSON.parse(JSON.stringify(arr));
console.timeEnd('【深拷贝】JSON.parse');

copyArr = [];
console.time('【深拷贝】lodash-es cloneDeep');
copyArr = cloneDeep(arr);
console.timeEnd('【深拷贝】lodash-es cloneDeep');

copyArr = [];
// 这个应该算浅拷贝，不过因为是基础类型，就划到深拷贝里了
console.time('【深拷贝】手动 for');
const length = arr.length;
copyArr = new Array(length);
for (let i = 0; i < length; i++) {
    copyArr[i] = arr[i];
}
console.timeEnd('【深拷贝】手动 for');

// 自己实现一个深拷贝，不考虑一些特殊场景
function deepClone(source) {
    if (typeof source !== 'object' || source == null) {
        return source;
    }
    const target = Array.isArray(source) ? [] : {};
    for (const key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
            if (typeof source[key] === 'object' && source[key] !== null) {
                target[key] = deepClone(source[key]);
            } else {
                target[key] = source[key];
            }
        }
    }
    return target;
}
copyArr = [];
console.time('【深拷贝】自己实现的deepClone');
copyArr = deepClone(arr);
console.timeEnd('【深拷贝】自己实现的deepClone');

copyArr = [];
console.time('【浅拷贝】lodash-es clone');
copyArr = clone(arr);
console.timeEnd('【浅拷贝】lodash-es clone');

copyArr = [];
console.time('【浅拷贝】concat');
copyArr = arr.concat();
console.timeEnd('【浅拷贝】concat');

copyArr = [];
console.time('【浅拷贝】slice');
copyArr = arr.slice();
console.timeEnd('【浅拷贝】slice');

copyArr = [];
console.time('【浅拷贝】Object.assign()');
copyArr = Object.assign([], arr);
console.timeEnd('【浅拷贝】Object.assign()');

copyArr = [];
console.time('【浅拷贝】手动 扩展运算符');
copyArr = [...arr];
console.timeEnd('【浅拷贝】手动 扩展运算符');

测试结果

                    

 深拷贝  浅拷贝 
JSONlodash cloneDeepfor自己实现的深拷贝loadash cloneconcatsliceObject.assign扩展运算符
数字999999.99999

1000万4.020s479.56ms94.122ms1.93s185.31ms37.38ms35.06ms8.198s73.90ms
10万22.823ms6.619ms2.079ms12.044ms1.907ms0.334ms0.372ms24.024ms0.411ms
10000.272ms0.638ms0.162ms0.301ms0.07ms0.008ms0.005ms0.241ms0.004ms
数字11000万613.693ms336.968ms57.705ms1.978s92.962ms72.879ms60.213ms5.626s56.124ms
10万5.207ms5.819ms1.663ms11.275ms1.661ms0.404ms0.32ms23.207ms0.305ms
10000.118ms0.606ms0.16ms0.338ms0.071ms0.008ms0.004ms0.227ms0.006ms

字符串

abcdefghijklmnopqrstuvwxyz

1000万3.938s355.628ms96.017ms2.092s129.239ms128.126ms52.62ms5.353s84.042ms
10万12.666ms5.993ms1.729ms10.609ms1.845ms0.306ms0.319ms23.48ms0.373ms
10000.169ms0.625ms0.174ms0.424ms0.122ms0.011ms0.011ms0.164ms0.005ms

结果分析

从测试结果上来看，浅拷贝的效率要比深拷贝高很多，所以如果数组中都是基础数据类型的化建议直接使用浅拷贝。

如果数组中都是基础数据类型，那么无脑浅拷贝就可以了。

数组深拷贝的时候在数据量大的时候loadash的cloneDeep性能比较好，如果数据量小的时候JSON API比较快。

JSON API的速度和数组转字符串（JSON.stringify）的长度有明显的关系。

浅拷贝中Object.assign太拉垮了。

测试二：属性全是基础类型的对象

测试代码

import {cloneDeep, clone} from "lodash-es";

const time = 1000 * 1000;
const obj = {};
const per = time / 5;
for (let i = 0; i < per; i++) {
    obj['test1111' + i] = i;
}
for (let i = 0; i < per; i++) {
    obj['APPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP' + i] = i.toString();
}
for (let i = 0; i < per; i++) {
    obj['XXXX' + i] = true;
}
for (let i = 0; i < per; i++) {
    obj['str11334566444' + i] = 1.111222333;
}
for (let i = 0; i < per; i++) {
    obj['str' + i] = '测试一个字符串';
}

let copy;
console.time('【深拷贝】JSON.parse');
copy = JSON.parse(JSON.stringify(obj));
console.timeEnd('【深拷贝】JSON.parse');

console.time('【深拷贝】lodash-es cloneDeep');
copy = cloneDeep(obj);
console.timeEnd('【深拷贝】lodash-es cloneDeep');

// 这个应该算浅拷贝，不过因为是基础类型，就划到深拷贝里了
console.time('【深拷贝】手动 for');
Object.keys(obj).forEach((key) => {
    copy[key] = obj[key];
})
console.timeEnd('【深拷贝】手动 for');

// 自己实现一个深拷贝，不考虑一些特殊场景
function deepClone(source) {
    if (typeof source !== 'object' || source == null) {
        return source;
    }
    const target = Array.isArray(source) ? [] : {};
    for (const key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
            if (typeof source[key] === 'object' && source[key] !== null) {
                target[key] = deepClone(source[key]);
            } else {
                target[key] = source[key];
            }
        }
    }
    return target;
}
console.time('【深拷贝】自己实现的deepClone');
copy = deepClone(obj);
console.timeEnd('【深拷贝】自己实现的deepClone');

console.time('【浅拷贝】lodash-es clone');
copy = clone(obj);
console.timeEnd('【浅拷贝】lodash-es clone');

console.time('【浅拷贝】Object.assign()');
copy = Object.assign({}, obj);
console.timeEnd('【浅拷贝】Object.assign()');

console.time('【浅拷贝】手动 扩展运算符');
copy = {...obj};
console.timeEnd('【浅拷贝】手动 扩展运算符');

测试结果

                    

深拷贝浅拷贝
JSONlodash cloneDeepfor自己实现的深拷贝loadash cloneObject.assign扩展运算符
100万1.620s605.588ms410.262ms607.865ms638.868ms930.889ms924.655ms
10万76.511ms43.793ms25.555ms49.19ms41.705ms57.76ms76.651ms
10000.468ms0.78ms0.172ms0.292ms0.318ms0.291ms2.736ms

结果分析

造1000W个属性的数据卡死了，估计实际场景也不会有这种对象，所以放弃了。

没想到浅拷贝的性能也不太理想，最好的居然是循环赋值。（如果数据都是基础数据类型，可以考虑自己循环实现拷贝）

测试三：属性中带有50%非基础类型的对象

测试代码

import {cloneDeep, clone} from "lodash-es";

const time = 1000 * 10;
const obj = {};
const per = time / 4;
for (let i = 0; i < per; i++) {
    obj['test1111' + i] = {
        name: 'name',
        sex: '男',
        age: 18,
        number: 22222222222,
        isDel: false,
        date: '2021-02-02',
    };
}
for (let i = 0; i < per; i++) {
    obj['APPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP' + i] = [1, 4, 'aaa', true, false, 99.22331, {
        name: 'name',
        sex: '男',
        age: 18,
        number: 22222222222,
        isDel: false,
        date: '2021-02-02',
    }];
}
for (let i = 0; i < per; i++) {
    obj['XXXX' + i] = true;
}
for (let i = 0; i < per; i++) {
    obj['str11334566444' + i] = i & 0 ? 10 : 1.111222333;
}

let copy;
console.time('【深拷贝】JSON.parse');
copy = JSON.parse(JSON.stringify(obj));
console.timeEnd('【深拷贝】JSON.parse');

console.time('【深拷贝】lodash-es cloneDeep');
copy = cloneDeep(obj);
console.timeEnd('【深拷贝】lodash-es cloneDeep');

// 自己实现一个深拷贝，不考虑一些特殊场景
function deepClone(source) {
    if (typeof source !== 'object' || source == null) {
        return source;
    }
    const target = Array.isArray(source) ? [] : {};
    for (const key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
            if (typeof source[key] === 'object' && source[key] !== null) {
                target[key] = deepClone(source[key]);
            } else {
                target[key] = source[key];
            }
        }
    }
    return target;
}
console.time('【深拷贝】自己实现的deepClone');
copy = deepClone(obj);
console.timeEnd('【深拷贝】自己实现的deepClone');

console.time('【浅拷贝】lodash-es clone');
copy = clone(obj);
console.timeEnd('【浅拷贝】lodash-es clone');

console.time('【浅拷贝】Object.assign()');
copy = Object.assign({}, obj);
console.timeEnd('【浅拷贝】Object.assign()');

console.time('【浅拷贝】手动 扩展运算符');
copy = {...obj};
console.timeEnd('【浅拷贝】手动 扩展运算符');

测试结果

                    

深拷贝浅拷贝
JSONlodash cloneDeep自己实现的深拷贝forloadash cloneObject.assign扩展运算符
100万2.142s1.716s1.074s365.295ms669.646ms1.017s991.849ms
10万166.046ms159.29ms80.986ms23.6ms42.761ms62.753ms62.581ms
10001.103ms3.927ms0.947ms0.17ms0.359ms0.351ms2.853ms

结果分析

有50%的属性为引用类型的情况下，浅拷贝的整体性能要优于深拷贝。其中自己实现循环仍然遥遥领先。（如果只要浅拷贝就可以的话可以试一试）

lodash-es 工具库常用工具函数和案例详解
前端知识分享喵
04-04 1万+
Lodash 是一个一致性、模块化、高性能的 JavaScript 实用工具库，算是从分离出来的超集。Lodash 通过降低 array、number、objects、string 等等的使用难度从而让 JavaScript 变得更简单。lodash为了良好的浏览器兼容性，它使用了旧版 es5 的模块语法；而lodash-es则使用了 es6 的模块语法，这让 webpack 之类的打包工具可以对其进行tree shake。
JavaScript API性能对比系列二：深拷贝和浅拷贝性能对比（二）
zzyp1927314的博客
06-26 1144
1. 如果能够选择浅拷贝的情况下请尽量选择浅拷贝（尤其是对象或者数组中都是基础类型，务必使用浅拷贝）。2. 浅拷贝如果是对象请使用lodash的clone方法，数组的话请使用扩展运算符[...arr]。3. 深拷贝中，我最后新加的测试场景【深拷贝】手动for + 手动赋值的性能实在是太好了，所以如果能够手动赋值还是尽量手动赋值。i++) {})4. 深拷贝中 在几千条以下的时候性能要比loadash的cloneDeep性能好。数据量大的情况下反之。
Java中的常用API大全【含浅拷贝深拷贝、正则表达式、BigDecimal、BigInteger底层存储方式等】
hou2735848363的博客
12-11 1653
java中常用的API大全【包含浅拷贝深拷贝、正则表达式、BigDecimal、BigInteger底层存储方式等】
Vue3+Vite中lodash-es安装与使用指南
最新发布
BillKu的博客
06-04 1540
始终按需导入避免全局导入：防止打包体积过大配合 Vite 的 Tree Shaking：现代构建工具会自动优化复杂操作优先使用 lodash：如深度克隆、防抖节流等按照这些步骤，您可以高效地在 Vue 3 + Vite 项目中使用 lodash-es，在保持小体积的同时获得强大的工具函数支持。
js深拷贝
知之为知之，不知为不知
05-22 184
js深拷贝
结构化克隆API的前世今生：从深拷贝到原生力量structuredClone()
球球不吃虾WHR2349博客
04-27 1057
并且，相比 JSON.parse() ，structuredClone API 的性能更好，特别是在处理一些更大复杂的对象的时候，所以我们可以用它来作为代码里深拷贝的默认方法啦，为了兼容性考虑，可以用 JSON.stringify 或者其他工具函数作为备用。与浅拷贝相对的就是深拷贝，深拷贝算法也会一个一个地拷贝一个对象的属性，但是当它拷贝对另一个对象的引用时会递归调用，同时创建该引用类型的一个副本，这可以有效避免我们在代码里共享一个意想不到的对象引用。当然，大部分实际的需求场景中，我们没必要拷贝这些东西。
纯原生实现深拷贝的接口
weixin_44095732的博客
03-28 126
纯原生实现深拷贝的接口 需要深拷贝的原因 在js当中非基本数据类型(引用类型)，在相互之间进行赋值的时候其实赋值的是指针，所以如果A引用类型赋值给B，是将A的指针赋给了B，所以在改变B里面内容的时候，A的内容会进行改变。在我们的需求中我们往往希望获取某个对象或数组的值，对其进行改变，而不影响原来的值。所以在这里就需要深拷贝，当然深拷贝有JQuery里面的$.extend( target [, object1 ] [, objectN ] );还有Object.assign()方法(但是该方法只能拷贝一层，如
深拷贝与浅拷贝接口
u013366966的专栏
01-24 235
子类继承拷贝父类，直接调用拷贝方法，子类需要序列化：   [Serializable] public class Cloneable&lt;T&gt; : ICloneable { public object Clone() { return MemberwiseClone(); } ...
前端经典面试题：深拷贝和浅拷贝
a253399414的博客
03-19 2306
一、写在前面 在任何编程语言中，都存在深拷贝和浅拷贝的概念，js当然也不例外。在对一个现有对象进行拷贝的时候是有深拷贝和浅拷贝之说的，他们在实际使用中区别还是挺大的，如果不弄清原因，可能在工作中遇到错误不好排查。 二、什么是深拷贝和浅拷贝 首先需要明白的一点是：深拷贝和浅拷贝针对的是对象进行操作的。那么就先来看看深拷贝和浅拷贝的具体概念。 在js中，除了基本数据类型以外，还存在引用数据类型。而在一般使用赋值语句=的时候。对于基本数据类型，实际上只是拷贝它的值，但是对于对象而言，其实赋值的是这个对象的内存引用
AngularJS API之copy深拷贝详解及实例
10-21
AngularJS中的API函数——angular.copy()是一个用于对象或数组深拷贝的工具。深拷贝（deep copy）操作意味着将对象或数组中的所有层级的属性或元素都复制到一个新的实例中，这与浅拷贝（shallow copy）相对，后者仅...
C#中的浅拷贝（Shallow Copy）和深拷贝（Deep Copy），深拷贝的集中实现方式，浅拷贝深拷贝的案例
weixin_43603714的博客
04-19 2428
拷贝就是创建一个对象，这个对象有着原始对象数据（属性和字段）的一份精确拷贝（只针对**Object**和**Array**这样的引用数据类型）。 换个说法就是：所谓的对象拷贝（复制）就是为对象创建副本，得到相同的对象。
JavaScript 中的深拷贝新宠：structuredClone() 函数详解
weixin_45274678的博客
08-21 1223
在 JavaScript 中，处理对象拷贝时，我们经常会遇到浅拷贝（shallow copy）和深拷贝（deep copy）的概念。浅拷贝只复制对象的第一层属性，如果属性值是引用类型（如对象、数组等），则只复制引用而不复制对象本身，这可能会导致原始数据被意外修改。而深拷贝则递归地复制对象及其所有子属性，确保原始数据和拷贝数据完全独立。传统上，JavaScript 没有内置直接进行深拷贝的函数，开发者通常需要自己编写深拷贝函数或使用第三方库（如 lodash 的 _.cloneDeep()）。
一篇文章带你了解cloneable接口、浅拷贝、深拷贝
Java鱼仔的博客
11-07 1292
cloneable接口有什么用，浅拷贝和深拷贝你知道吗？
深拷贝和浅拷贝的区别
SMY_API的专栏
07-02 637
ios中并不是所有的对象都支持copy，mutableCopy，遵守NSCopying 协议的类可以发送copy消息，遵守NSMutableCopying 协议的类才可以发送mutableCopy消息。假如发送了一个没有遵守上诉两协议而发送 copy或者 mutableCopy,那么就会发生异常。但是默认的ios类并没有遵守这两个协议。如果想自定义一下copy 那么就必须遵守NSCopying,并
lodash常用方法
Rex的博客
03-28 1782
lodash常用方法安装数组处理方法1、_.chunk(array, [size=1])2、_.drop(array, [n=1])3、_.dropRight(array, [n=1])4、_.fill(array, value, [start=0], [end=array.length])`（*会改变原始数组 array）`5、_.flatten(array)、_.flattenDeep(array)、_.flattenDepth(array, [depth=1])6、_.pull(array, valu
lodash-es 详解
html网页设计、web前后端网站制作、大学生网页设计作业、jQuery网站设计、uniapp小程序、vue网站设计、网页成品模板、期末大作业，各种源码应有尽有，持续更新中...
04-16 2274
是使用 ​​ 语法从lodash-es包中按需导入cloneDeep函数。
vue 中 lodash-es 常用库实用库
weixin_42113341的博客
01-16 1301
库的 ES 模块版本，提供了大量实用的函数来简化 JavaScript 中的数据操作、数组处理、对象操作、函数式编程等任务。这些函数可以极大地提高开发效率，减少重复代码，使代码更加简洁和易于维护。根据您的具体需求，选择合适的函数，可以帮助您更高效地处理数据。提供了丰富的函数，涵盖了数组操作、对象操作、函数式编程、字符串操作等多个方面。
lodash之cloneDeep()源码阅读笔记
求知路上
08-14 1811
思路大概是：首先判断要复制的对象是否为原始类型，如果是原始类型则直接返回该值。如果是引用类型（如对象或数组），则进行深度复制。创建一个新的空对象或数组作为目标对象。遍历要复制的对象的属性或元素，对每一个属性或元素进行递归复制，直到所有嵌套的对象或数组都被复制为止。使用递归复制的方式，将源对象或数组的属性或元素复制到目标对象或数组中。如果属性或元素本身是一个引用类型，则递归调用 baseClone 进行深度复制。返回复制完成的目标对象或数组。
vue3父子传值
weixin_42112342的博客
05-12 451
vue3+ts 父子传参
js 深拷贝和浅拷贝
03-16
<think>好的，我现在需要回答用户关于JavaScript中深拷贝和浅拷贝的区别及实现方法的问题。首先，我得回忆一下自己之前学过的相关知识，确保理解正确。 用户的问题明确，需要了解区别和实现方式。根据之前提供的引用内容，引用[1]和[2]都提到了深拷贝和浅拷贝的概念，以及实现方法。引用[3]还提到了使用JSON方法、递归和第三方库如lodash。现在需要把这些信息整合起来，结构清晰地呈现出来。 首先，应该先解释基本概念。浅拷贝是复制对象的顶层属性，如果属性是基本类型，直接复制值；如果是引用类型，则复制内存地址，导致新旧对象共享同一引用，修改其中一个会影响另一个。深拷贝则是完全复制所有层级的属性，新旧对象完全独立，互不影响。这点需要明确区分，可能用例子说明会更清楚。 接下来是区别部分。根据引用[3]，区别主要有拷贝层级、实现方式和性能不同。需要详细说明这三个方面，比如浅拷贝只复制一层，深拷贝递归复制所有层级；实现方式上，浅拷贝可以用Object.assign或展开运算符，深拷贝则用JSON方法、递归或第三方库；性能方面，深拷贝因为递归遍历可能更耗资源，尤其是处理大对象时。 然后是实现方式。对于浅拷贝，常见的几种方法需要列出，比如Object.assign()，数组的slice和concat方法，展开运算符...。这里需要给出示例代码，并说明这些方法的使用和限制，比如只能处理一层。 深拷贝的实现方式较多。JSON.parse(JSON.stringify(obj))是最简单的方式，但存在局限性，比如无法处理函数、undefined、循环引用等。递归方法需要手动实现，遍历对象的每个属性，如果是对象则递归复制，这里可能需要示例代码说明。第三方库如lodash的cloneDeep方法，用户只需调用即可，但要提醒需要安装库。另外，可能还可以提到其他方法，比如使用MessageChannel或者structuredClone（较新的API），但需注意浏览器兼容性。 注意事项部分，需要指出深拷贝的潜在问题，比如循环引用会导致递归爆栈，特殊对象如Date、RegExp等可能需要特殊处理，JSON方法不能处理函数等。这些内容引用[2]和[3]都有提到，需要整合进来。 最后，总结应用场景。浅拷贝适用于简单对象且不需要嵌套修改的情况，深拷贝用于复杂对象需要完全独立副本的情况。这部分帮助用户根据需求选择合适的方法。 现在需要检查是否有遗漏点，比如递归实现的代码是否正确，是否覆盖了所有实现方式，以及是否引用了正确的来源。同时，确保语言简洁，结构清晰，符合用户要求的中文回答，数学公式正确使用$...$，但在这个问题中可能不涉及数学公式，所以重点在代码块和结构。</think>### JavaScript中深拷贝与浅拷贝的区别及实现方法 #### 1. **基本概念** - **浅拷贝（Shallow Copy）** 仅复制对象的**顶层属性**。若属性是基本类型（如`number`, `string`），直接复制值；若属性是引用类型（如`object`, `array`），则复制内存地址。因此，新旧对象会**共享嵌套的引用类型数据**，修改其中一个会影响另一个[^1][^3]。 **示例**： ```javascript const obj = { a: 1, b: { c: 2 } }; const shallowCopy = Object.assign({}, obj); shallowCopy.b.c = 3; console.log(obj.b.c); // 输出 3（原对象被修改） ``` - **深拷贝（Deep Copy）** 完全递归复制对象的所有层级属性，生成一个**完全独立的新对象**。新旧对象不共享任何引用类型数据[^2][^3]。 **示例**： ```javascript const obj = { a: 1, b: { c: 2 } }; const deepCopy = JSON.parse(JSON.stringify(obj)); deepCopy.b.c = 3; console.log(obj.b.c); // 输出 2（原对象未被修改） ``` --- #### 2. **核心区别** | 特性 | 浅拷贝 | 深拷贝 | |--------------|--------------------------------------------|--------------------------------------------| | **拷贝层级** | 仅复制顶层属性 | 递归复制所有层级的属性 | | **实现方式** | `Object.assign()`、展开运算符`...` | `JSON.parse(JSON.stringify())`、递归、第三方库 | | **性能影响** | 高效 | 可能因递归遍历或复杂对象导致性能损耗 | | **共享引用** | 嵌套对象共享同一内存地址 | 完全独立，不共享任何引用 | --- #### 3. **实现方式** ##### **浅拷贝的实现** 1. **`Object.assign()`** ```javascript const shallowCopy = Object.assign({}, originalObj); ``` 2. **展开运算符`...`** ```javascript const shallowCopy = { ...originalObj }; ``` 3. **数组的`slice()`和`concat()`** ```javascript const arrCopy = originalArr.slice(); ``` ##### **深拷贝的实现** 1. **`JSON.parse(JSON.stringify())`** 最简单但局限性较大： - 无法处理函数、`undefined`、`Symbol`。 - 会丢失`Date`对象（转为字符串）、忽略循环引用。 ```javascript const deepCopy = JSON.parse(JSON.stringify(originalObj)); ``` 2. **递归实现** 手动遍历对象属性并递归复制： ```javascript function deepClone(obj) { if (typeof obj !== 'object' || obj === null) return obj; const result = Array.isArray(obj) ? [] : {}; for (const key in obj) { if (obj.hasOwnProperty(key)) { result[key] = deepClone(obj[key]); } } return result; } ``` 3. **第三方库（如`lodash`）** 使用现成的工具函数： ```javascript import { cloneDeep } from 'lodash'; const deepCopy = cloneDeep(originalObj); ``` --- #### 4. **注意事项** - **循环引用问题**：若对象存在循环引用（如`obj.a = obj`），递归方法会栈溢出，需通过缓存解决。 - **特殊对象处理**：`Date`、`RegExp`、`Map`等类型需单独处理。 - **性能权衡**：深拷贝对大型对象或频繁操作可能影响性能。 --- #### 5. **应用场景** - **浅拷贝**：简单对象且无需修改嵌套属性时（如配置合并）。 - **深拷贝**：需完全独立副本的场景（如状态管理、撤销操作）。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值