本文详细解析JavaScript中深拷贝的四种常见实现方式。从基础的JSON序列化法到ES6的Object.assign，再到处理循环引用的递归与WeakMap方案，逐一分析其原理、缺陷及适用场景，帮助开发者根据实际需求选择最优解。
浅拷贝与深拷贝
浅拷贝是指构建一个新对象，该对象包含原始对象属性值的副本。若属性为基本数据类型，则复制其具体数值；若属性为引用类型，则仅复制内存地址。
若未执行深拷贝，修改任一对象中的值将波及另一个对象。深拷贝则是从内存中完整复制一份对象，在堆内存中开辟全新区域存储新对象，确保修改新对象不会干扰原对象。
1、JSON.parse(JSON.stringify(obj))序列化和反序列
该方法先将目标对象转换为JSON字符串，再通过JSON.parse解析回对象并赋值给新变量，以此实现深拷贝。
let a = {a:1,b:2}
let b = JSON.parse(JSON.stringify(a))
a.a = 11
1.1 JSON.parse(JSON.stringify(obj))深浅拷贝的缺陷
let a = {
name: 'Jack',
age: 18,
hobbit: ['sing', {type: 'sports', value: 'run'}],
score: {
math: 'A',
},
run: function() {},
walk: undefined,
fly: NaN,
cy: null,
date: new Date()
}
let b = JSON.parse(JSON.stringify(a))
此方法存在多项局限：无法保留值为undefined的键；若对象包含函数，函数无法被正确拷贝；无法处理原型链上的属性和方法；Date对象会被转换为字符串。
2、Object.assign(target, source1, source2)
这是ES6新增的方法，主要用于对象合并，可将源对象的所有可枚举属性复制到目标对象上。
var data = {
a: "123",
b: 123,
c: true,
d: [43, 2],
e: undefined,
f: null,
g: function() { console.log("g"); },
h: new Set([3, 2, null]),
i: Symbol("fsd"),
k: new Map([ ["name", "张三"], ["title", "Author"] ])
};
var newData = Object.assign({},data)
console.log(newData) 
虽然该API能将源对象的所有数据类型属性值复制到新对象，但这并非完美的深拷贝方案。实际上，它属于部分深拷贝，甚至可视为浅拷贝，具体原因如下文所述。
var test = { name: '张三' }
var data = {
a: 123,
b: test
}
var newData = Object.assign({},data)
console.log(newData)
// { a: 123, b: { name: '张三' }}
test.age = 18
console.log(newData)
// { a: 123, b: { name: '张三', age: 18 }}结果显示，若源对象中某属性值引用了另一个对象，该属性的拷贝依然只是对引用的复制，而非深层内容的独立副本。
3、普通递归函数实现深拷贝
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;
}3.1、解决循环引用和symblo类型
function cloneDeep(source, hash = new WeakMap()) {
if (typeof source !== 'object' || source === null) {
return source;
}
if (hash.has(source)) {
return hash.get(source);
}
const target = Array.isArray(source) ? [] : {};
Reflect.ownKeys(source).forEach(key => {
const val = source[key];
if (typeof val === 'object' && val != null) {
target[key] = cloneDeep(val, hash);
} else {
target[key] = val;
}
})
return target;
}4. 迭代递归方法（解决闭环问题）
function deepCopy(data, hash = new WeakMap()) {
if(typeof data !== 'object' || data === null){
throw new TypeError('传入参数不是对象')
}
// 判断传入的待拷贝对象的引用是否存在于hash中
if(hash.has(data)) {
return hash.get(data)
}
let newData = {};
const dataKeys = Object.keys(data);
dataKeys.forEach(value => {
const currentDataValue = data[value];
// 基本数据类型的值和函数直接赋值拷贝
if (typeof currentDataValue !== "object" || currentDataValue === null) {
newData[value] = currentDataValue;
} else if (Array.isArray(currentDataValue)) {
// 实现数组的深拷贝
newData[value] = [...currentDataValue];
} else if (currentDataValue instanceof Set) {
// 实现set数据的深拷贝
newData[value] = new Set([...currentDataValue]);
} else if (currentDataValue instanceof Map) {
// 实现map数据的深拷贝
newData[value] = new Map([...currentDataValue]);
} else {
// 将这个待拷贝对象的引用存于hash中
hash.set(data,data)
// 普通对象则递归赋值
newData[value] = deepCopy(currentDataValue, hash);
}
});
return newData;
}相较于1.0版本，此方法引入了WeakMap作为对象存储容器。其核心思路是：首次调用deepCopy时，参数会创建一个WeakMap结构的对象。这种数据结构的特点是，存储键值对中的键必须是对象类型。
- 首次调用时，weakMap为空，不会执行if(hash.has())语句。若待拷贝对象中包含属性也为对象的情况，则将该待拷贝对象存入weakMap中，此时键值和键名均指向该待拷贝对象的引用。
- 随后递归调用该函数。
- 再次进入函数时，传入的是上一个待拷贝对象中属性对象的引用，以及存储了上一个待拷贝对象引用的weakMap。如果是循环引用产生的闭环，这两个引用指向同一对象，因此会进入if(hash.has())语句内并return，从而退出函数，避免无限递归导致栈溢出。
总结
上述几种方式各有优劣，共同点是仅能拷贝对象的可枚举属性。对于不可枚举属性或原型链上的属性，它们无法处理。但对于基本使用场景，这些方法已足够。
到此这篇关于JS深拷贝的4种实现方法的文章就介绍到这了,更多相关JS深拷贝内容请搜索本站以前的文章或继续浏览下面的相关文章希望大家以后多多支持本站！