怎么用JS递归遍历并修改深层嵌套JSON对象

作者:函数茶馆

时间:2026-11-18

浏览:281

深入讲解如何使用 JavaScript 递归算法遍历并修改任意深层嵌套的 JSON 对象与数组。涵盖基础 DFS 实现、在位修改与不可变克隆两种范式、处理数组与对象的边界技巧,以及使用 WeakSet 防范循环引用的生产级方案。

文章目录
作者:技术实战 分类:JavaScript / 算法实践 深度遍历 递归修改 JSON数据清洗
怎么用JS递归遍历并修改深层嵌套JSON对象
缩略图概览:基于深度优先搜索(DFS)的任意深度嵌套 JSON 对象属性匹配与递归改写
遍历并修改深层嵌套 JSON 对象的标准做法是使用深度优先遍历(DFS)递归函数:在遍历当前节点的属性时,通过类型检查判定是否为复合对象或数组;如果是,则递归下探遍历其子属性;一旦匹配到目标键名或符合特定判定条件的值,便执行修改操作。针对实际业务,修改方式主要分为“在位修改(直接变更原对象)”与“不可变更新(返回克隆新对象)”两种模式。

一、核心思路与类型判断的防坑要点

JSON 数据在 JavaScript 运行时中会解析为基本类型(字符串、数值、布尔值、null)以及复合类型(普通对象 Object 和数组 Array)。由于嵌套结构可能存在任意层级,传统的单层 for...in 或 Object.keys() 无法触及内层数据,必须通过递归将未知深度的树状结构逐步压栈展开。

在编写递归前,最容易被忽略且导致运行报错的细节是类型判断。JavaScript 中 typeof null === 'object',如果仅使用 typeof target === 'object' 作为进入下一层递归的依据,程序读取 null 的属性时便会抛出 TypeError: Cannot read properties of null。因此,判定当前节点能否继续深层遍历的严密条件必须写为:

const isRecord = (val) => val !== null && typeof val === 'object';

无论外层是对象还是数组,只要满足 isRecord,就能对其包含的每个元素或键名进行枚举,并把子节点继续交给递归函数处理。

怎么用JS递归遍历并修改深层嵌套JSON对象
图 1:深层递归遍历与修改的执行步骤流程

二、模式一:在位修改(In-Place Mutation)

在位修改是指直接在传入的原始对象上重写符合条件的属性值。这种模式不需要为每个层级分配新的内存空间,适合处理体积庞大、深达数千层、且后续流程不需要保留原始快照的数据清洗或离线转换任务。

下面是一个通用的在位修改函数 traverseAndMutate。函数接受三个参数:需要遍历修改的目标数据 data、用于判断何时修改的断言函数 predicate、以及返回新值的修改函数 modifier。

/**
 * 在位递归遍历并修改 JSON 对象
 * @param {Object|Array} target - 目标对象或数组
 * @param {Function} predicate - 判断匹配规则: (value, key, parent) => boolean
 * @param {Function} modifier - 产生新值的转换函数: (value, key, parent) => any
 */
function traverseAndMutate(target, predicate, modifier) {
  // 基本类型或 null 直接返回
  if (target === null || typeof target !== 'object') {
    return target;
  }

  // 分支处理:数组按索引遍历,普通对象按 Object.keys 遍历
  const keys = Array.isArray(target) 
    ? Array.from({ length: target.length }, (_, i) => i)
    : Object.keys(target);

  for (const key of keys) {
    const value = target[key];

    // 优先检查当前键值是否命中目标判定规则
    if (predicate(value, key, target)) {
      target[key] = modifier(value, key, target);
    }

    // 若属性值仍是对象或数组,则递归下探
    if (target[key] !== null && typeof target[key] === 'object') {
      traverseAndMutate(target[key], predicate, modifier);
    }
  }

  return target;
}

执行示例:将所有价格转换为保留两位小数的浮点数

const rawCart = {
  id: "order_8091",
  buyer: { name: "张三", level: "VIP" },
  groups: [
    {
      category: "图书",
      items: [
        { title: "JS进阶", price: "59.9", count: 1 },
        { title: "算法导论", price: 120, count: 2 }
      ]
    }
  ]
};

// 执行在位递归修改
traverseAndMutate(
  rawCart,
  (val, key) => key === 'price',
  (val) => Number(parseFloat(val).toFixed(2))
);

console.log(rawCart.groups[0].items[0].price); // 示例输出:59.9
console.log(rawCart.groups[0].items[1].price); // 示例输出:120

三、模式二:纯函数不可变更新(Immutable Deep Transform)

在现代前端应用(如 React、Redux、Vue 3 响应式系统)中,在位修改原对象会破坏引用相等性检测(Reference Equality Check),导致视图无法触发重新渲染。此时应当使用纯函数不可变更新:遍历时不改动原始 JSON,而是逐层返回结构副本,仅在修改的目标节点及其父级链路上产生全新引用。

怎么用JS递归遍历并修改深层嵌套JSON对象
图 2:在位修改(In-Place)与不可变更新(Immutable)机制对比
/**
 * 不可变递归修改深层嵌套 JSON 对象
 * @returns {*} 返回深层修改后的全新克隆对象
 */
function deepTransformImmutable(data, predicate, modifier, key = null, parent = null) {
  // 1. 如果当前节点命中条件,先通过 modifier 获得转换后的值
  let current = data;
  if (predicate(current, key, parent)) {
    current = modifier(current, key, parent);
  }

  // 2. 如果转换后非对象或为 null,直接返回该基本值
  if (current === null || typeof current !== 'object') {
    return current;
  }

  // 3. 处理数组情况:使用 map 生成全新数组
  if (Array.isArray(current)) {
    return current.map((item, index) => 
      deepTransformImmutable(item, predicate, modifier, index, current)
    );
  }

  // 4. 处理普通对象:累加新对象
  const nextObject = {};
  for (const [k, v] of Object.entries(current)) {
    nextObject[k] = deepTransformImmutable(v, predicate, modifier, k, current);
  }

  return nextObject;
}
方案优势:原始传入的 rawCart 变量保持只读不变,新生成的对象与原对象完全解耦。对于复杂的深层数据表单重置、撤销恢复功能,此方式具有天然的安全保证。

四、防范陷阱:循环引用与最大调用栈溢出

实际生产中,某些 JSON 数据可能是由内部运行时模型转化而来,或者通过挂载属性无意间构成了循环引用(Circular Reference)——例如某个子对象的 parent 属性指向了父级自身。如果无保护地递归遍历,程序将迅速耗尽 JavaScript 调用栈,抛出 RangeError: Maximum call stack size exceeded。

要杜绝死循环,最佳方案是在递归入口引入 WeakSet。WeakSet 具有弱引用特性,不会阻止垃圾回收器对已无用对象的内存释放,非常适合作为一次遍历生命周期内的“已访问(visited)”登记表。

怎么用JS递归遍历并修改深层嵌套JSON对象
图 3:循环引用检测与 WeakSet 防死循环防护机制

生产级高可靠递归修改实现

/**
 * 生产级安全递归修改函数(带循环引用守卫与键名替换支持)
 */
function safeDeepMutate(
  target, 
  valueRule = null, 
  keyRenameRule = null, 
  seen = new WeakSet()
) {
  if (target === null || typeof target !== 'object') {
    return target;
  }

  // 环形引用检测:若此前已访问过该引用,立即跳出
  if (seen.has(target)) {
    return target;
  }
  seen.add(target);

  // 针对数组:仅遍历索引和元素
  if (Array.isArray(target)) {
    for (let i = 0; i < target.length; i++) {
      if (valueRule && valueRule.match(target[i], i, target)) {
        target[i] = valueRule.modify(target[i], i, target);
      }
      safeDeepMutate(target[i], valueRule, keyRenameRule, seen);
    }
    return target;
  }

  // 针对普通对象:支持属性值修改与属性键名改名
  const entries = Object.entries(target);
  for (const [key, value] of entries) {
    let finalKey = key;
    let finalVal = value;

    // 1. 值转换
    if (valueRule && valueRule.match(value, key, target)) {
      finalVal = valueRule.modify(value, key, target);
      target[key] = finalVal;
    }

    // 2. 键名替换(例如把下划线命名转为驼峰)
    if (keyRenameRule && keyRenameRule.match(key)) {
      finalKey = keyRenameRule.rename(key);
      if (finalKey !== key) {
        target[finalKey] = finalVal;
        delete target[key];
      }
    }

    // 3. 递归深入
    safeDeepMutate(finalVal, valueRule, keyRenameRule, seen);
  }

  return target;
}

五、实战演练:批量递归清洗敏感字段(脱敏与键重构)

为了验证上述实现的效果,我们模拟一段多层嵌套的用户与组织数据,要求递归遍历完成两件事:

  1. 将所有深层嵌套中键名为 idCard 和 mobile 的字符串进行掩码脱敏。
  2. 将名为 user_code 的下划线属性名重命名为 userCode。
const enterpriseData = {
  deptName: "研发中心",
  user_code: "RD_001",
  leader: {
    name: "李四",
    idCard: "110101199003072345",
    mobile: "13800138000"
  },
  teams: [
    {
      teamName: "前端组",
      members: [
        { name: "王五", mobile: "13912345678", user_code: "FE_002" }
      ]
    }
  ]
};

// 构造循环引用测试容错
enterpriseData.selfRef = enterpriseData;

// 启动安全遍历清洗
safeDeepMutate(
  enterpriseData,
  {
    match: (val, key) => ['idCard', 'mobile'].includes(key),
    modify: (val) => String(val).replace(/(\d{3})\d+(\d{4})/, '$1****$2')
  },
  {
    match: (key) => key === 'user_code',
    rename: () => 'userCode'
  }
);

console.log(enterpriseData.leader.idCard); 
// 示例输出:"110****2345"

console.log(enterpriseData.teams[0].members[0].mobile); 
// 示例输出:"139****5678"

console.log(enterpriseData.teams[0].members[0].userCode); 
// 示例输出:"FE_002" (原 user_code 已自动迁移)

六、方案选型与技术总结

在实际工程中,面对深层嵌套 JSON 遍历修改时,应根据数据规模和应用场景合理选择实现方案:

对比维度 在位修改(In-Place) 不可变更新(Immutable) 非递归显式栈(BFS/DFS)
内存占用 极低(直接重用原有内存) 较高(需生成多份层级拷贝) 中等(需维护自定义数组堆栈)
副作用控制 有副作用,直接改变源对象 零副作用,天然契合纯函数 视具体赋值逻辑而定
极限深度防护 受 JS 调用栈深度限制(约 1万层) 受 JS 调用栈深度限制 无调用栈限制,仅受系统内存限制
典型应用场景 Node.js 批处理、网关接口返回报文过滤 React/Vue 状态流管理、Redux Reducer 外部不信任数据、超大型树/AST 语法树解析
怎么用JS递归遍历并修改深层嵌套JSON对象
图 4:深层 JSON 递归与修改方案选型决策导图
注意事项与最佳实践总结:
  1. 必须统一判定 val !== null && typeof val === 'object',严防空指针异常。
  2. 数组与普通对象的子项枚举方式不同,遍历数组优先用索引驱动,对象用 Object.entries() 或 Object.keys()。
  3. 如果数据源包含反向指针(如树节点关联父节点),必须挂载 WeakSet 作为记忆缓存拦截环形调用。
  4. 在修改对象键名时,应注意在赋值新键后删除旧键,避免残留脏字段。

实用工具推荐

电子包浆

绿化、压缩、噪点和虚拟水印,自由调节做旧程度。

使用 ›
图片压缩

选择画质和输出格式,预览压缩前后的大小。

使用 ›
相关文章