JS动态构建复杂嵌套JSON对象的方法

一、核心思路与路径分词机制

构建嵌套对象最常见的痛点在于“层级深度未知”与“数据容器类型未知”。在编写静态业务逻辑时，我们可以直接书写 data.a.b.c = value；但在动态表单收集、动态配置合并等场景下，键名是在运行时动态获取的字符串。

实现动态设值的第一步，是将各种格式的路径字符串解析为标准的键（Key）数组。常见的路径格式包括：

• 纯点分路径："user.profile.age" ➔ ["user", "profile", "age"]
• 带数组下标路径："orders[0].items[1].name" ➔ ["orders", "0", "items", "1", "name"]
• 混合下划线与多层括号："data['tags'][0]" ➔ ["data", "tags", "0"]

为了统一处理，我们通常使用正则表达式将所有的括号语法 [index] 转换为点分语法 .index，再进行统一拆分：

function normalizePath(path) {
  if (Array.isArray(path)) return path;
  // 将 [0] 转换为 .0，并将连续的点与首尾点清除
  return String(path)
    .replace(/\[\s*(['"]?)(.*?)\s*\]/g, '.$2')
    .replace(/^\./, '')
    .split('.')
    .filter(Boolean);
}

在得到键数组后，内存寻址采用指针下沉（Pointer Sinking）算法：从传入的根对象引用出发，让指针变量 current 随着遍历逐层深入。对于中间层级，若当前属性不存在，则自动初始化；若已存在，则复用现有对象，避免同级字段丢失。

二、动态设值函数的标准实现步骤

实现一个健壮的动态嵌套构建函数，核心需要处理好三个关键转折点：安全防御判断、中间容器类型推断以及叶子节点写入。

1. 前瞻类型推断规则

许多初学者在构建嵌套结构时容易踩坑：当遍历到 "items" 时，应该将其初始化为普通对象 {} 还是数组 []？

核心法则在于前瞻（Lookahead）：当前层级的容器形态，不取决于当前键名，而是由其“紧邻的下一级键名”决定的。如果下一个键是全数字字符（例如 "0"、"1"），说明下一级是通过数组索引访问，当前层级必须初始化为数组；否则初始化为普通字典对象。

2. 生产级完整代码实现

下面是一个无第三方依赖的 setDeepValue 完整实现：

/**
 * 动态向对象中注入深层嵌套值
 * @param {Object} target 目标对象
 * @param {string|Array} path 路径字符串或数组
 * @param {*} value 欲设置的值
 * @returns {Object} 修改后的目标对象
 */
function setDeepValue(target, path, value) {
  if (!target || typeof target !== 'object') {
    throw new TypeError('目标必须是非空对象或数组');
  }

  const tokens = normalizePath(path);
  if (tokens.length === 0) return target;

  let current = target;

  for (let i = 0; i < tokens.length; i++) {
    const key = tokens[i];

    // 步骤一：严格防范原型污染攻击
    if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
      continue;
    }

    // 步骤二：若到达最后一个 key，执行赋值
    if (i === tokens.length - 1) {
      current[key] = value;
      break;
    }

    // 步骤三：若中间节点不存在或不是对象，依据下一级 key 推导类型
    const nextKey = tokens[i + 1];
    const isNextIndex = /^\d+$/.test(nextKey);

    if (!current[key] || typeof current[key] !== 'object') {
      current[key] = isNextIndex ? [] : {};
    }

    // 步骤四：指针下沉进入下一层
    current = current[key];
  }

  return target;
}

三、数组与对象的混合嵌套处理与聚合

在实际工程中，最典型的一个需求是将表单的 FormData 或 URLSearchParams 转换为符合 API 规范的多层 JSON 结构。例如一个动态订单表单提交了商品列表、收货地址与优惠券信息：

批量转换实战代码

通过循环结合 setDeepValue，我们可以用极简的代码完成复杂扁平数据的重组：

// 扁平数据源（如来自表单序列化或 CSV 解析行）
const flatFormData = [
  ['order.id', 'ORD-2026-8801'],
  ['order.customer.name', '张三'],
  ['order.customer.contact.email', 'zhangsan@example.com'],
  ['order.items[0].sku', 'CPU-9900X'],
  ['order.items[0].quantity', 2],
  ['order.items[1].sku', 'RAM-32G'],
  ['order.items[1].quantity', 4]
];

function assembleNestedJSON(entries) {
  const result = {};
  for (const [path, val] of entries) {
    setDeepValue(result, path, val);
  }
  return result;
}

const nestedResult = assembleNestedJSON(flatFormData);
console.log(JSON.stringify(nestedResult, null, 2));

执行后生成的对象结构如下，完全符合现代 RESTful API 的入参标准：

{
  "order": {
    "id": "ORD-2026-8801",
    "customer": {
      "name": "张三",
      "contact": {
        "email": "zhangsan@example.com"
      }
    },
    "items": [
      { "sku": "CPU-9900X", "quantity": 2 },
      { "sku": "RAM-32G", "quantity": 4 }
    ]
  }
}

四、安全防御与架构决策

就地修改 vs 不可变模式的选择

如果在 React 等需要不可变（Immutable）更新的场景中，我们可以采用结构共享递归的方式改写叶子节点，保持未受影响的引用不变：

function setDeepImmutable(obj, path, value) {
  const tokens = normalizePath(path);
  if (tokens.length === 0) return value;

  const [head, ...rest] = tokens;
  if (head === '__proto__' || head === 'constructor') return obj;

  const isNextArr = rest.length > 0 && /^\d+$/.test(rest[0]);
  const isHeadArr = Array.isArray(obj);

  // 克隆当前层级容器
  const cloned = isHeadArr ? [...(obj || [])] : { ...(obj || {}) };

  if (rest.length === 0) {
    cloned[head] = value;
  } else {
    const currentChild = cloned[head] || (isNextArr ? [] : {});
    cloned[head] = setDeepImmutable(currentChild, rest, value);
  }

  return cloned;
}

五、总结与速查清单

动态构建复杂嵌套 JSON 对象并不需要引入臃肿的外部工具库。理解其底层的指针下沉机制后，十几行原生 JavaScript 代码便足以优雅解决问题。在实际运用中，请务必核对以下清单：

1. 路径规范化：兼容点分与方括号下标，消除首尾无效点；
2. 类型前瞻推导：由下一级键名是数字还是标识符，准确初始化 [] 或 {}；
3. 安全防御：严密拦截 __proto__ 等敏感键，杜绝原型污染；
4. 容器复用：对于已有中间节点保持引用，不盲目覆写已有同级数据。