如何将对象数组转换为多层嵌套对象？技术方案问询

问题描述 #

我有一组对象数组，每个对象都指定了其父级名称（如有）。如何将其转换为单个嵌套对象？我在处理2层及以上的嵌套时遇到了困难。

期望输出 #

{ 
  "REPORTING PERIOD": "2022",
  "SIGNATURE DATE": "20211005",
  "HOUSE": {
    "OWNER DATA": {
      "FIRST NAME": "Joe",
      "LAST NAME": "Smith"
    },
    "VALUE HISTORY": {
      "INITAL PRICE": "12345",
      "LAST SALE PRICE": "1231236"
    },
    "ADDRESS": {
      "STREET 1": "5 MAIN TERRACE",
      "CITY": "LONDON"
    }
  },
  "AGENT": {
    "COMPANY DATA": {
      "COMPANY NAME": "The Real Agent, Inc",
      "BUSINESS NUMBER": "0021690080"
    },
    "BUSINESS ADDRESS": {
      "STREET 1": "800 MENLO STREET, SUITE 100",
      "CITY": "MENLO PARK",
      "ZIP": "94025"
    }
  }
}

输入数据 #

const data = [
    {
        "rank": 0,
        "key": "REPORTING PERIOD",
        "value": "2022",
        "parent": ""
    },
    {
        "rank": 0,
        "key": "SIGNATURE DATE",
        "value": "20211005",
        "parent": ""
    },
   
    {
        "rank": 0,
        "key": "HOUSE",
        "value": "",
        "parent": ""
    },
    {
        "rank": 1,
        "key": "OWNER DATA",
        "value": "",
        "parent": "HOUSE"
    },
    {
        "rank": 2,
        "key": "FIRST NAME",
        "value": "Joe",
        "parent": "OWNER DATA"
    },
    {
        "rank": 2,
        "key": "LAST NAME",
        "value": "Smith",
        "parent": "OWNER DATA"
    },
    {
        "rank": 1,
        "key": "VALUE HISTORY",
        "value": "",
        "parent": "HOUSE"
    },
    {
        "rank": 2,
        "key": "INITAL PRICE",
        "value": "12345",
        "parent": "VALUE HISTORY"
    },
    {
        "rank": 2,
        "key": "LAST SALE PRICE",
        "value": "1231236",
        "parent": "VALUE HISTORY"
    },
    {
        "rank": 1,
        "key": "ADDRESS",
        "value": "",
        "parent": "HOUSE"
    },
    {
        "rank": 2,
        "key": "STREET 1",
        "value": "5 MAIN TERRACE",
        "parent": "ADDRESS"
    },
    {
        "rank": 2,
        "key": "CITY",
        "value": "LONDON",
        "parent": "ADDRESS"
    },   
    {
        "rank": 0,
        "key": "AGENT",
        "value": "",
        "parent": ""
    },
    {
        "rank": 1,
        "key": "COMPANY DATA",
        "value": "",
        "parent": "AGENT"
    },
    {
        "rank": 2,
        "key": "COMPANY NAME",
        "value": "The Real Agent, Inc",
        "parent": "COMPANY DATA"
    },
    {
        "rank": 2,
        "key": "BUSINESS NUMBER",
        "value": "0021690080",
        "parent": "COMPANY DATA"
    },
    
    {
        "rank": 1,
        "key": "BUSINESS ADDRESS",
        "value": "",
        "parent": "AGENT"
    },
    {
        "rank": 2,
        "key": "STREET 1",
        "value": "800 MENLO STREET, SUITE 100",
        "parent": "BUSINESS ADDRESS"
    },
    {
        "rank": 2,
        "key": "CITY",
        "value": "MENLO PARK",
        "parent": "BUSINESS ADDRESS"
    },
    {
        "rank": 2,
        "key": "ZIP",
        "value": "94025",
        "parent": "BUSINESS ADDRESS"
    }  
]

现有代码（存在嵌套问题） #

const resultObject: Record<string, unknown> = {};

//loop through array
for (const obj of data) {
    const { key, value, parent } = obj;

    if (parent === " " || parent === "" || parent === undefined) {
      resultObject[key] = value; // 无父级时直接作为根属性
    } else {
      // 有父级时挂载到父级下
      if (!resultObject[parent]) {
        resultObject[parent] = {}; // 父级不存在则创建空对象
      }
      (resultObject[parent] as Record<string, unknown>)[key] = value;
    }
  }
  console.log(resultObject);

解决方案 #

现有代码的问题是仅能处理一层嵌套，无法定位深层父级的实际位置。我们可以通过节点映射表记录每个节点的引用，再按父级关系组装嵌套结构，支持任意层级嵌套。

实现代码 #

const nodeMap: Record<string, any> = {};
const result: Record<string, any> = {};

// 第一步：初始化所有节点，建立映射关系
for (const item of data) {
    const { key, value, parent } = item;
    // 非空值直接赋值，空值作为容器节点创建空对象
    const node = value ? value : {};
    nodeMap[key] = node;
    
    // 根节点直接加入结果对象
    if (!parent) {
        result[key] = node;
    }
}

// 第二步：根据父级关系挂载子节点
for (const item of data) {
    const { key, parent } = item;
    // 父级存在时，将子节点挂载到父节点对象中
    if (parent && nodeMap[parent]) {
        nodeMap[parent][key] = nodeMap[key];
    }
}

console.log(result);

代码说明 #

1. 节点映射表：nodeMap存储每个key对应的对象或值，能快速找到任意节点的引用，避免深层查找的麻烦。
2. 分两步处理：
   • 先初始化所有节点，根节点直接放入结果，容器节点初始化为空对象。
   • 再遍历节点，利用对象引用直接将子节点挂载到对应父节点上，自然形成多层嵌套。
3. 扩展性：不管嵌套层级多少，只要父级节点存在，就能正确完成挂载，完全适配需求。

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