递归闭包不是独立深克隆技术，而是用闭包包裹递归函数，使WeakMap能持久保存对象-克隆体映射，从而安全处理循环引用；WeakMap避免内存泄漏，闭包确保状态私有稳定。
递归闭包不是一种独立的深克隆技术，而是指在递归实现中自然利用闭包机制保存状态（比如 WeakMap 引用映射），从而安全处理循环引用。关键不在于“闭包”本身，而在于用闭包包裹递归函数，使哈希表（如 WeakMap）能稳定维持在整个克隆过程中——这是解决循环引用的核心设计。
为什么需要 WeakMap + 闭包来处理循环引用
当对象 A 的某个属性指向自身，或 A→B→A 构成环时，纯递归会无限调用直至栈溢出。必须在进入递归前检查该对象是否已被克隆过。WeakMap 能以原始对象为 key 存储其对应克隆体，且不阻止垃圾回收，是理想选择。而闭包让这个 WeakMap 在多次递归调用间保持私有、持久、不可篡改。
例如：
- 原始对象
obj = { a: 1 }; obj.self = obj; - 第一次遇到
obj：新建空对象，存入hash.set(obj, clone) - 递归处理
obj.self时再次碰到obj：查hash.has(obj)为 true，直接返回已存的clone，终止深入
手写一个带闭包保护的递归深克隆函数
下面是一个完整、可运行的实现，封装了 WeakMap 和递归逻辑，自动支持 Date、RegExp、Array、Object、Map、Set、Symbol 属性，并正确处理循环引用：
dmap-jsapi-skill
下载
DMap GL地图JSAPI（dmapgl）开发指南。用于编写、审查、调试 DMap 地图 API 代码，涵盖地图初始化、覆盖物渲染、图层管理、事件处理、控件交互等任务。当用户提及 dmap、dmapgl、jsapi‑gl 或相关地图开发需求时自动触发。
（注意：不依赖外部库，原生 JavaScript 即可运行）
function deepClone(obj) {
const hash = new WeakMap();
function clone(value) {
// 基本类型、null、函数、undefined 直接返回
if (value === null || typeof value !== 'object') return value;
// 循环引用检测
if (hash.has(value)) return hash.get(value);
// 处理 Date
if (value instanceof Date) {
const copy = new Date(value.getTime());
hash.set(value, copy);
return copy;
}
// 处理 RegExp
if (value instanceof RegExp) {
const copy = new RegExp(value.source, value.flags);
hash.set(value, copy);
return copy;
}
// 处理 Map
if (value instanceof Map) {
const copy = new Map();
hash.set(value, copy);
value.forEach((v, k) => copy.set(clone(k), clone(v)));
return copy;
}
// 处理 Set
if (value instanceof Set) {
const copy = new Set();
hash.set(value, copy);
value.forEach(v => copy.add(clone(v)));
return copy;
}
// 处理数组
if (Array.isArray(value)) {
const copy = [];
hash.set(value, copy);
value.forEach((item, i) => copy[i] = clone(item));
return copy;
}
// 处理普通对象（含 Symbol 属性）
const copy = Object.create(Object.getPrototypeOf(value));
hash.set(value, copy);
// 拷贝自有可枚举属性（字符串 key）
for (const key in value) {
if (Object.prototype.hasOwnProperty.call(value, key)) {
copy[key] = clone(value[key]);
}
}
// 拷贝 Symbol 属性
const symbols = Object.getOwnPropertySymbols(value);
for (const sym of symbols) {
const descriptor = Object.getOwnPropertyDescriptor(value, sym);
if (descriptor && descriptor.enumerable) {
Object.defineProperty(copy, sym, {
value: clone(value[sym]),
enumerable: true,
writable: true,
configurable: true
});
}
}
return copy;
}
return clone(obj);
}
验证循环引用是否真正被解决
运行以下测试代码，确认克隆后对象结构完整、引用隔离、且无报错：
const a = { name: 'a' };
const b = { name: 'b', ref: a };
a.ref = b; // 形成 a ↔ b 循环
const cloned = deepClone(a);
console.log(cloned.ref.ref === cloned); // true（内部循环仍存在，但已是新对象）
console.log(cloned === a); // false
console.log(cloned.ref === b); // false
console.log(cloned.ref.ref === cloned); // true，说明结构保留且自洽
输出为 true 表明：克隆体内部形成了独立的循环关系，与原始对象完全解耦——这正是深度克隆对循环引用的正确处理目标。
什么情况下不该用这个方案
虽然健壮，但并非万能：
- 不能克隆
function的作用域链或闭包变量（JS 语言限制，任何深克隆都做不到） - 无法复制
Promise、TypedArray子类（如Uint8Array）、error对象等，需按需扩展判断分支 - 性能敏感场景（如每秒克隆上万次小对象），JSON 方法仍更快（但仅限无循环、无特殊类型的纯数据）
