如何利用“递归闭包”处理具有循环引用的复杂 JSON 对象深度克隆-js教程-PHP中文网

递归闭包不是独立深克隆技术，而是用闭包包裹递归函数，使weakmap能持久保存对象-克隆体映射，从而安全处理循环引用；weakmap避免内存泄漏，闭包确保状态私有稳定。

如何利用“递归闭包”处理具有循环引用的复杂 json 对象深度克隆

递归闭包不是一种独立的深克隆技术，而是指在递归实现中自然利用闭包机制保存状态（比如 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 表明：克隆体内部形成了独立的循环关系，与原始对象完全解耦——这正是深度克隆对循环引用的正确处理目标。