json.parse(json.stringify(obj)) 不能深拷贝一切，它会丢失或转换函数、undefined、symbol、regexp、date等类型，且不支持循环引用；2. 实现真正深拷贝的推荐方法是使用 structuredclone()，它能处理大多数内置对象和循环引用，但不支持函数和dom节点；3. 当需更高灵活性或兼容旧环境时，可自定义递归深拷贝函数，通过 weakmap 处理循环引用，并手动处理 date、regexp 等特殊类型；4. 深拷贝与浅拷贝的本质区别在于是否递归复制所有嵌套引用，深拷贝确保新旧对象完全独立；5. 选择方法时应权衡数据复杂度、环境兼容性和性能需求，优先使用 structuredclone()，其次考虑 json 方法或自定义函数，必要时引入 lodash 等库的 clonedeep 方法以获得最佳兼容性和健壮性。
在JavaScript里，深拷贝一个对象意味着你需要创建一个全新的对象，它不仅复制了原始对象的所有属性值，更重要的是，如果这些属性值本身是引用类型（比如另一个对象或数组），深拷贝会递归地复制它们，确保新旧对象之间没有任何共享的引用。这样一来，你修改新对象的任何部分，都不会影响到原始对象。这与浅拷贝形成鲜明对比，浅拷贝仅仅复制顶层属性，嵌套的引用类型依然指向同一个内存地址。
解决方案
要实现一个可靠的深拷贝，根据你的具体场景和目标环境，有几种主流且实用的方法。
一种是利用
JSON
对象的序列化和反序列化能力。这种方式简洁明了，但有其局限性：
function deepCloneByJson(obj) { try { return JSON.parse(JSON.stringify(obj)); } catch (e) { console.error("JSON深拷贝失败，可能存在不可序列化的数据类型或循环引用:", e); // 根据实际情况，这里可以返回原始对象或抛出错误 return obj; }}// 示例const originalObj = { a: 1, b: { c: 2 }, d: [3, { e: 4 }], f: new Date(), // 会被转换为字符串 g: undefined, // 会丢失 h: function() {}, // 会丢失 i: Symbol('test') // 会丢失};const clonedObj = deepCloneByJson(originalObj);console.log(clonedObj);// { a: 1, b: { c: 2 }, d: [ 3, { e: 4 } ], f: '2023-10-27T08:00:00.000Z' }// 可以看到f变成了字符串，g、h、i都丢失了
另一种，也是现代浏览器和Node.js环境中更推荐的方法，是使用
structuredClone()
API。它设计之初就是为了解决复杂数据类型的深拷贝问题，并且能很好地处理循环引用：
function deepCloneStructured(obj) { if (typeof structuredClone === 'function') { try { return structuredClone(obj); } catch (e) { console.error("structuredClone深拷贝失败，可能存在不可克隆的数据类型（如函数、DOM节点等）:", e); return obj; // 失败时返回原始对象 } } else { // 兼容性处理，如果不支持structuredClone，退而求其次使用JSON方法 console.warn("当前环境不支持structuredClone，尝试使用JSON方法进行深拷贝，但可能存在限制。"); return deepCloneByJson(obj); }}// 示例const originalComplexObj = { name: 'Test', details: { id: 123, timestamp: new Date(), regex: /abc/g }, list: [1, 2, { nested: 'item' }], func: () => console.log('hello'), circular: null};originalComplexObj.circular = originalComplexObj; // 制造一个循环引用const clonedComplexObj = deepCloneStructured(originalComplexObj);console.log(clonedComplexObj);// 可以看到timestamp和regex都被正确克隆，且func会被忽略（因为不可克隆）// 循环引用也会被正确处理
JSON.parse(JSON.stringify(obj))
JSON.parse(JSON.stringify(obj))
真的能深拷贝一切吗？
说实话，不能。虽然它在很多场景下非常方便，尤其是处理那些只包含数字、字符串、布尔值、null、普通对象和数组的“纯粹”JSON数据时，简直是神器。一行代码搞定，性能也不错。但一旦你的对象里开始出现一些“不那么JSON”的东西，比如
Date
对象、
RegExp
对象、
undefined
、
NaN
、
Infinity
、函数、
Symbol
、
Map
、
Set
，甚至是 DOM 节点或者复杂的类实例，它就力不从心了。
举个例子，
Date
对象会被转换成ISO格式的字符串，而不是一个新的
Date
实例。
undefined
、函数和
Symbol
类型的属性会直接被忽略掉。
NaN
和
Infinity
会变成
null
。更要命的是，如果你的对象存在循环引用（就是对象A引用了对象B，对象B又引用了对象A），
JSON.stringify()
会直接抛出错误，导致整个拷贝过程失败。这就像你试图用一个筛子去装水，总有些东西会漏掉或者变形。所以，如果对数据类型有严格要求，或者对象结构比较复杂，就得小心使用这种方法了。
面对复杂数据类型，如何实现真正的深拷贝？
当
JSON.parse(JSON.stringify())
的局限性变得无法接受时，我们通常会转向更强大的工具。在现代JavaScript世界里，
structuredClone()
API无疑是首选。它被设计来处理那些通过
postMessage
传递的数据类型，这意味着它能深拷贝大多数内置对象类型，包括
Date
、
RegExp
、
Map
、
Set
、
ArrayBuffer
、
TypedArray
、
ImageData
、
Blob
、
File
等，而且最关键的是，它能优雅地处理循环引用，不会像
JSON.stringify
那样直接报错。这让它在处理复杂数据结构时显得非常“省心”。
然而，
structuredClone()
也有它的“脾气”。它不能克隆函数（因为函数是不可结构化克隆的），也不能克隆 DOM 节点、Error 对象以及一些特殊的主机对象。对于这些不可克隆的类型，它会直接抛出
DataCloneError
。
那么，如果连
structuredClone()
都无法满足，比如你需要克隆一个包含函数的特定类实例，或者你的运行环境不支持
structuredClone()
怎么办？这时候，自定义递归深拷贝函数就派上用场了。虽然实现起来会复杂一些，尤其要考虑周全各种数据类型和循环引用，但它提供了最大的灵活性。
一个基本的递归实现思路是：
判断当前值是否为原始类型或
null
，是则直接返回。判断是否为对象或数组。处理循环引用：维护一个
Map
或
WeakMap
来存储已拷贝过的对象和它们对应的克隆，避免无限递归。根据是对象还是数组，创建新的空对象或空数组。遍历原始对象的属性，对每个属性值递归调用深拷贝函数。
function customDeepClone(obj, hash = new WeakMap()) { // 处理原始类型和null if (obj === null || typeof obj !== 'object') { return obj; } // 处理日期对象 if (obj instanceof Date) { return new Date(obj); } // 处理正则表达式 if (obj instanceof RegExp) { return new RegExp(obj.source, obj.flags); } // 处理循环引用 if (hash.has(obj)) { return hash.get(obj); } // 创建新对象或新数组 const clone = Array.isArray(obj) ? [] : {}; hash.set(obj, clone); // 在递归之前将克隆对象放入hash // 递归拷贝属性 for (let key in obj) { // 确保只拷贝对象自身的属性，不包括原型链上的 if (Object.prototype.hasOwnProperty.call(obj, key)) { clone[key] = customDeepClone(obj[key], hash); } } return clone;}// 示例：包含函数、循环引用、日期和正则const originalCustom = { a: 1, b: { c: 2 }, d: [3, { e: 4 }], f: new Date(), g: /test/gi, h: function() { console.log('hello'); }, i: Symbol('id'), // Symbol类型会直接被拷贝，但其值是唯一的 j: null};originalCustom.j = originalCustom; // 制造循环引用const clonedCustom = customDeepClone(originalCustom);console.log(clonedCustom);// 可以看到日期和正则被正确克隆为新实例，函数也被拷贝了（虽然通常不推荐拷贝函数）// 循环引用也被处理了
这种自定义方法提供了最大的控制力，但实现起来也更考验功力，尤其是要确保没有遗漏各种边缘情况和特殊类型。在实际项目中，如果不是特别定制化的需求，我个人更倾向于优先考虑
structuredClone()
。
深拷贝与浅拷贝的本质区别是什么？
深拷贝和浅拷贝，这两个概念是理解JavaScript中对象复制的关键。它们的本质区别在于：是否彻底断开新旧对象在内存中的所有引用关系。
浅拷贝，顾名思义，它只会复制对象或数组的顶层属性。这意味着，如果原始对象中的某个属性值是基本类型（如数字、字符串、布尔值），那么新对象会得到一个独立的副本。但如果属性值是引用类型（比如另一个对象或数组），那么新对象复制的仅仅是这个引用本身的地址，而不是引用指向的实际内容。结果就是，新旧对象会共享这个嵌套的引用类型。你修改新对象中这个嵌套引用类型的属性，原始对象也会受到影响，反之亦然。这就像你复制了一本书的目录，但书页本身还是同一本。
常见的浅拷贝方式有：
展开运算符 (
...
)：用于对象或数组。
const obj1 = { a: 1, b: { c: 2 } };const shallowCopy1 = { ...obj1 };shallowCopy1.b.c = 3; // obj1.b.c 也会变成 3
Object.assign()
：用于对象合并。
const obj2 = { a: 1, b: { c: 2 } };const shallowCopy2 = Object.assign({}, obj2);shallowCopy2.b.c = 4; // obj2.b.c 也会变成 4
Array.prototype.slice()
或
Array.from()
：用于数组。
const arr1 = [1, { a: 2 }];const shallowCopyArr1 = arr1.slice();shallowCopyArr1[1].a = 3; // arr1[1].a 也会变成 3
而深拷贝则完全不同。它会递归地复制原始对象的所有层级，包括所有嵌套的引用类型。每当遇到一个引用类型，它都会创建一个全新的实例，并把原始实例的内容复制过去。这样一来，新对象和原始对象在内存中是完全独立的，它们之间没有任何共享的引用。你对新对象的任何修改，都不会对原始对象产生副作用，反之亦然。这就像你把一本书的每一页都复印了一遍，现在你有了两本完全独立但内容相同的书。这种彻底的独立性，正是深拷贝的价值所在。
选择深拷贝方法时，性能和兼容性如何权衡？
在选择深拷贝方法时，我通常会先问自己几个问题：
数据复杂吗？ 有没有
Date
、
RegExp
、
Map
、
Set
、循环引用，或者更奇葩的比如
Blob
、
File
？目标环境是什么？ 是现代浏览器、Node.js，还是需要兼容老旧IE浏览器？性能要求高吗？ 是拷贝一个小型配置对象，还是一个包含成千上万个嵌套对象的巨型数据结构？
基于这些考量，我个人会这样权衡：
JSON.parse(JSON.stringify(obj))
：
优点： 简单、代码量少、兼容性极好（几乎所有JavaScript环境都支持）、对于只包含JSON安全类型的小型到中型对象，性能通常不错。缺点： 局限性大，会丢失或转换非JSON安全类型（前面提过）。对于包含大量数据或深层嵌套的对象，性能可能不如
structuredClone
。适用场景： 快速深拷贝简单对象，例如从服务器获取的纯数据，或者你明确知道对象里没有那些“麻烦”的数据类型。我经常用它来快速复制一些配置对象，如果我确定它们不会有函数或日期等。
structuredClone()
：
优点： 功能强大，能处理大多数内置数据类型，包括
Date
、
RegExp
、
Map
、
Set
、
ArrayBuffer
等，还能优雅处理循环引用。性能通常比
JSON.parse(JSON.stringify())
更好，尤其是在处理大型或复杂数据时。缺点： 兼容性相对较新（需要较新的浏览器环境或Node.js 17+），不能克隆函数、DOM节点、Error对象等。适用场景： 当你需要深拷贝复杂数据结构，且目标环境支持时，这是我的首选。它省去了编写复杂递归逻辑的麻烦，同时提供了很好的健壮性。
自定义递归深拷贝函数：
优点： 灵活性最高，可以根据具体需求定制拷贝逻辑，例如，你可以决定是否拷贝函数、如何处理特定的类实例，或者在拷贝过程中进行数据转换。兼容性由你代码决定，可以支持所有环境。缺点： 实现复杂，容易出错（特别是处理循环引用和各种边缘类型），维护成本高。性能可能不如内置方法，尤其是在没有经过优化的情况下。适用场景： 当
structuredClone()
无法满足你的特殊需求（例如必须拷贝函数），或者你需要支持非常老的JavaScript环境时。我个人只有在“万不得已”或者有非常明确的定制需求时才会去手写这种函数。
第三方库（如Lodash的
_.cloneDeep()
）：
优点： 功能全面，考虑了各种复杂的边缘情况和数据类型，包括函数、DOM节点等（尽管通常不会深度拷贝DOM节点，但会妥善处理）。经过高度优化，性能通常也很好。缺点： 引入额外依赖，增加了项目体积。适用场景： 如果你的项目已经使用了Lodash或其他类似工具库，或者你需要一个经过充分测试且功能强大的通用深拷贝方案，那么使用它们提供的
cloneDeep
方法会是一个非常省心且可靠的选择。
总结一下，我的建议是：优先考虑
structuredClone()
，它兼顾了功能和性能，是现代Web开发的理想选择。如果环境不支持或有特定不可克隆类型的需求，再考虑自定义递归函数。而
JSON.parse(JSON.stringify())
更多是作为快速、简单的“万金油”，但要牢记它的局限性。
以上就是js 怎么深拷贝一个对象的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1517001.html
微信扫一扫 
支付宝扫一扫 
