JavaScript实现嵌套层级JSON解析 关联引用对象递归展开

需求规则 #

需要对指定结构的JSON数组做嵌套解析，规则如下：

• 当对象的Key等于special时可存在嵌套结构
• 需将对象的Next字段、specialkey数组每一项的value值、RepeatText与RepeatTextNew字段存储的id值，替换为数组中对应id的完整对象
• 从数组第一个元素开始递归处理生成目标嵌套结构

输入示例 #

[
  {
    "id": "p1",
    "top": 130,
    "left": 298,
    "Key": "test1",
    "Next": "special"
  },
  {
    "id": "p2",
    "Key": "special",
    "specialkey": [
      {"key": "1", "value": "p3"},
      {"key": "0", "value": "p4"},
      {"key": "2", "value": "p5"}
    ],
    "Next": "",
    "RepeatText": "p8",
    "RepeatTextNew": "p9",
  },
  {
    "id": "p3",
    "user": "aa",
    "Key": "test3",
    "Text": "hi"
  },
  {
    "id": "p4",
    "Key": "special",
    "specialkey": [
      {"key": "1", "value": "p6"},
      {"key": "0", "value": "p7"}
    ]
  },
  {
    "id": "p5",
    "user": "aa",
    "Key": "test5",
    "Text": "hi"
  },
  {
    "id": "p6",
    "user": "aa",
    "Key": "test6",
    "Text": "hi"
  },
  {
    "id": "p7",
    "user": "aa",
    "Key": "test7",
    "Text": "hi"
  },
  {
    "id": "p8",
    "user": "aa",
    "Key": "test8",
    "Text": "hi"
  },
 {
    "id": "p9",
    "user": "aa",
    "Key": "test9",
    "Text": "hi"
  }
]

预期输出 #

{
  "test1": {
    "id": "p1",
    "top": 130,
    "left": 298,
    "Key": "test1",
    "Next": {
      "special": {
        "id": "p2",
        "Key": "special",
        "Next": "",
        "RepeatText": {
          "p8": {
            "id": "p8",
            "user": "aa",
            "Key": "test8",
            "Text": "hi"
          }
        },
        "RepeatTextNew": {
          "p9": {
            "id": "p9",
            "user": "aa",
            "Key": "test9",
            "Text": "hi"
          }
        },
        "specialkey": [
          {
            "key": "1",
            "value": {
              "id": "p3",
              "user": "aa",
              "Key": "test3",
              "Text": "hi"
            }
          },
          {
            "key": "0",
            "value": {
              "id": "p4",
              "Key": "special",
              "specialkey": [
                {
                  "key": "1",
                  "value": {
                    "id": "p6",
                    "user": "aa",
                    "Key": "test6",
                    "Text": "hi"
                  }
                },
                {
                  "key": "0",
                  "value": {
                    "id": "p7",
                    "user": "aa",
                    "Key": "test7",
                    "Text": "hi"
                  }
                }
              ]
            }
          },
          {
            "key": "2",
            "value": {
              "id": "p5",
              "user": "aa",
              "Key": "test5",
              "Text": "hi"
            }
          }
        ]
      }
    }
  }
}

原有代码问题 #

• 未预先建立id到对象的映射，重复使用find查询效率低，且无法处理Next值为special的匹配逻辑
• 缺失RepeatText、RepeatTextNew两个字段的替换逻辑
• special类型对象的处理逻辑全局硬查找第一个special对象，未与当前处理上下文绑定，递归逻辑混乱
• 直接修改原数组对象，会产生副作用

修正后完整实现代码 #

function parseNestedJson(formatData) {
  // 预先建立id和key到对象的映射表，提高查询效率
  const idMap = new Map();
  const keyMap = new Map();
  formatData.forEach(item => {
    idMap.set(item.id, {...item}); // 浅拷贝避免修改原数据
    keyMap.set(item.Key, {...item});
  });

  // 递归处理对象函数
  const processObject = (obj) => {
    const result = {...obj};
    // 处理Next字段
    if (result.Next && result.Next.trim()) {
      // Next值优先匹配id，其次匹配key
      const nextObj = idMap.get(result.Next) || keyMap.get(result.Next);
      if (nextObj) {
        result.Next = {
          [nextObj.Key]: processObject(nextObj)
        };
      }
    }
    // 处理special类型对象的额外字段
    if (result.Key === 'special') {
      // 处理specialkey数组
      if (Array.isArray(result.specialkey)) {
        result.specialkey = result.specialkey.map(item => {
          const targetObj = idMap.get(item.value);
          return {
            ...item,
            value: targetObj ? processObject(targetObj) : item.value
          };
        });
      }
      // 处理RepeatText
      if (result.RepeatText && result.RepeatText.trim()) {
        const repeatObj = idMap.get(result.RepeatText);
        if (repeatObj) {
          result.RepeatText = {
            [repeatObj.id]: processObject(repeatObj)
          };
        }
      }
      // 处理RepeatTextNew
      if (result.RepeatTextNew && result.RepeatTextNew.trim()) {
        const repeatNewObj = idMap.get(result.RepeatTextNew);
        if (repeatNewObj) {
          result.RepeatTextNew = {
            [repeatNewObj.id]: processObject(repeatNewObj)
          };
        }
      }
    }
    return result;
  };

  // 从第一个元素开始生成结果
  const firstItem = formatData[0];
  return {
    [firstItem.Key]: processObject({...firstItem})
  };
}

// 调用示例
// const result = parseNestedJson(你的输入数组);
// console.log(JSON.stringify(result, null, 2));

内容的提问来源于stack exchange，提问作者user13000875