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()
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))
说实话，不能。虽然它在很多场景下非常方便，尤其是处理那些只包含数字、字符串、布尔值、null、普通对象和数组的“纯粹”JSON数据时，简直是神器。一行代码搞定，性能也不错。但一旦你的对象里开始出现一些“不那么JSON”的东西，比如
Date
RegExp
undefined
NaN
Infinity
Symbol
Map
Set
举个例子，
Date
Date
undefined
Symbol
NaN
Infinity
null
JSON.stringify()
当
JSON.parse(JSON.stringify())
structuredClone()
postMessage
Date
RegExp
Map
Set
ArrayBuffer
TypedArray
ImageData
Blob
File
JSON.stringify
然而，
structuredClone()
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 也会变成 3Object.assign()
const obj2 = { a: 1, b: { c: 2 } };
const shallowCopy2 = Object.assign({}, obj2);
shallowCopy2.b.c = 4; // obj2.b.c 也会变成 4Array.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
基于这些考量，我个人会这样权衡：
JSON.parse(JSON.stringify(obj))
structuredClone
structuredClone()
Date
RegExp
Map
Set
ArrayBuffer
JSON.parse(JSON.stringify())
自定义递归深拷贝函数：
structuredClone()
第三方库（如Lodash的_.cloneDeep()
cloneDeep
总结一下，我的建议是：优先考虑
structuredClone()
JSON.parse(JSON.stringify())
以上就是js 怎么深拷贝一个对象的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
129
收藏
