将扁平对象数组转换为多层级嵌套对象-js教程-PHP中文网

将扁平对象数组转换为多层级嵌套对象

本文详细介绍了如何利用JavaScript的`Array.prototype.reduce`方法，将一个包含父子关系信息的扁平对象数组高效地转换为一个多层级嵌套的对象结构。通过巧妙运用空值合并赋值运算符（`??=`），我们能以简洁的方式处理多层级嵌套，构建出符合预期树状结构的复杂对象。

在现代JavaScript开发中，数据结构的转换是一项常见任务。有时，我们会遇到一种扁平化的数据表示，其中每个对象都通过一个parent字段来指示其父级，但我们最终需要一个多层级嵌套的对象来更好地反映其层级关系。本教程将深入探讨如何高效地实现这种转换，尤其是在处理2、3层甚至更多层级嵌套时遇到的挑战。

理解问题：扁平数据与目标结构

我们通常会从一个数组开始，其中每个元素都是一个包含key、value和parent属性的对象。parent字段指定了当前对象应该归属的父级key。如果parent为空，则表示该对象是顶级元素。

输入示例：

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" },
    // ... 更多数据
];

登录后复制

期望的输出结构：

{
  "REPORTING PERIOD": "2022",
  "SIGNATURE DATE": "20211005",
  "HOUSE": {
    "OWNER DATA": {
      "FIRST NAME": "Joe",
      "LAST NAME": "Smith"
    },
    // ... 其他 HOUSE 内部的嵌套对象
  },
  // ... 其他顶级对象
}

登录后复制

显而易见，挑战在于如何动态地创建和引用这些嵌套层级，确保每个子元素都能正确地放置在其父元素之下。

传统迭代方法的局限性

一种直观的尝试是遍历数组，根据parent字段将元素添加到结果对象中。

北极象沉浸式AI翻译

免费的北极象沉浸式AI翻译 - 带您走进沉浸式AI的双语对照体验

查看详情

const resultObject = {};
for (const obj of data) {
    const { key, value, parent } = obj;

    if (parent === "" || parent === undefined) {
      resultObject[key] = value; // 顶级元素
    } else {
      // 如果父级不存在，创建一个空对象
      if (!resultObject[parent]) {
        resultObject[parent] = {};
      }
      // 将当前元素作为子属性添加到父级对象中
      (resultObject[parent])[key] = value;
    }
}
console.log(resultObject);

登录后复制

这种方法的问题在于，它只能正确处理一级嵌套。例如，"FIRST NAME"的父级是"OWNER DATA"，而"OWNER DATA"的父级是"HOUSE"。上述代码会将"FIRST NAME"直接添加到resultObject["OWNER DATA"]中，但resultObject["OWNER DATA"]本身可能还未被正确地嵌套到resultObject["HOUSE"]中，或者resultObject["OWNER DATA"]可能被错误地初始化为 {} 而不是作为HOUSE的子属性。它无法在一次循环中动态地追踪和构建任意深度的嵌套路径。

解决方案：利用 Array.prototype.reduce 和 ??=

要高效地处理多层级嵌套，我们可以使用 Array.prototype.reduce 方法。reduce允许我们遍历数组并累积一个单一的结果。关键在于，我们可以利用reduce的累加器（accumulator）来同时作为我们构建的目标对象和查找父级节点的映射表。

核心思路：

累加器作为映射表： reduce的累加器 (a) 将不仅存储最终的嵌套对象，还将存储所有已处理的父节点（包括中间节点）的引用。这使得我们可以在处理子节点时，快速找到其父节点的实际引用。
空值合并赋值 (??=): 这个运算符 (a.property ??= value) 可以在 a.property 为 null 或 undefined 时，将其赋值为 value，并返回 a.property 的值。这极大地简化了“如果不存在则创建”的逻辑。
处理中间父节点： 当一个元素的value为空字符串时，它通常表示一个中间的父节点（如"HOUSE"、"OWNER DATA"）。对于这类节点，我们不直接赋值其value，而是确保它在累加器中是一个对象，以便后续的子节点可以添加到其中。
最终结果提取： 我们的顶级节点（parent: ""）会最终累积到累加器中的 a[''] 键下，所以最终结果就是 a['']。

示例代码：

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 tree = data.reduce((accumulator, { parent, key, value }) => {
  // 1. 确保父节点存在于累加器中，如果不存在则初始化为 {}
  // (accumulator[parent] ??= {}) 会返回 accumulator[parent] 的引用
  // 2. 在获取到的父节点引用上，设置当前 key 的值
  // 3. 如果当前 value 为空字符串，表示它是一个中间父节点，
  //    则将其值设置为一个新的空对象 (accumulator[key] ??= {})，
  //    以便后续的子节点可以添加到这个对象中。
  //    否则，直接赋值其 value。
  (accumulator[parent] ??= {})[key] = value === '' ? (accumulator[key] ??= {}) : value;

  return accumulator; // 返回更新后的累加器
}, {})['']; // 初始累加器为空对象，并最终取出 'parent: ""' 对应的顶级结构
// 注意：最后的 [''] 是为了从累加器中提取最终的根对象，
// 因为所有顶级元素 (parent 为 "") 都会被归类到 accumulator[''] 中。

console.log(JSON.stringify(tree, null, 2));

登录后复制

代码解析：

data.reduce((accumulator, { parent, key, value }) => { ... }, {})：
- reduce方法遍历data数组。
- accumulator（简写为a）是累加器，它在每次迭代中传递并累积结果。初始值是一个空对象{}。
- { parent, key, value }是解构赋值，从当前处理的数组元素中提取这三个属性。
(accumulator[parent] ??= {})：
- 这是整个解决方案的核心。它首先尝试访问 accumulator[parent]。
- 如果 accumulator[parent] 是 null 或 undefined（即这个父节点是第一次出现），??= 运算符会将其赋值为一个新的空对象 {}。
- 无论 accumulator[parent] 原本是否存在，这个表达式都会返回 accumulator[parent] 的引用。这意味着我们现在有了一个指向正确父级对象的引用，无论是新创建的还是已存在的。
[key] = value === '' ? (accumulator[key] ??= {}) : value;：
- 在获取到的父节点引用上，我们设置 key 属性的值。
- value === '' ? (accumulator[key] ??= {}) : value 是一个三元表达式：
  - 如果 value 为空字符串：这表示当前的key（例如"HOUSE"或"OWNER DATA"）本身是一个中间父节点，它应该包含其他子节点。因此，我们不能直接给它赋值一个空字符串。相反，我们确保 accumulator[key] 也是一个对象 (accumulator[key] ??= {})，并将其引用赋值给父节点下的 key。这样做的好处是，accumulator[key]这个新的对象引用也会被存入到全局的accumulator中，以便后续的子节点可以直接找到它并添加到它下面。
  - 如果 value 不为空字符串：这表示当前的key是一个叶子节点（例如"FIRST NAME"），直接将其value赋值给它即可。
return accumulator;：在每次迭代结束时，返回更新后的累加器，以便下一次迭代使用。
['']：reduce方法执行完毕后，accumulator对象会包含所有中间和最终的节点引用。由于所有顶级元素（parent为空字符串）都最终被归类到 accumulator[''] 之下，因此通过 [''] 我们可以直接获取到最终的、完整的嵌套对象结构。

注意事项与最佳实践

parent字段的规范性： 确保parent字段的值与某个key字段的值精确匹配。任何拼写错误或不一致都可能导致节点无法正确归属。
循环引用： 这种方法假设数据中不存在循环引用（即A是B的父，B是A的父）。如果存在循环引用，可能会导致无限递归或意外行为。
性能： reduce方法在一次遍历中完成所有操作，对于大多数数据集来说效率很高。对于极大的数据集，其性能表现良好，因为避免了多次查找和不必要的对象创建。
rank字段的用途： 在原始数据中存在rank字段，但在本解决方案中并未直接使用。如果rank字段有特定的业务逻辑需求（例如排序或验证），可能需要在reduce逻辑中加入额外的处理。

总结

通过巧妙地运用 Array.prototype.reduce 方法和 nullish coalescing assignment (??=) 运算符，我们可以高效且简洁地将一个扁平化的对象数组转换为任意深度的嵌套对象。这种模式在处理具有父子关系的数据转换时非常强大和灵活，是JavaScript开发中一个值得掌握的技巧。理解其工作原理不仅能解决当前问题，还能为处理其他复杂数据结构转换提供思路。

以上就是将扁平对象数组转换为多层级嵌套对象的详细内容，更多请关注php中文网其它相关文章！