按超过 2 层深的条件合并嵌套对象

Question

我有一组非常简单的对象：

[
  { category: 'A', level: 'Aa', sublevel: 'Aaa' },
  { category: 'A', level: 'Aa', sublevel: 'Aab' },
  { category: 'A', level: 'Ab', sublevel: 'Abb' },
  { category: 'B', level: 'Ac', sublevel: 'Abc' }
]

子级别始终是唯一的，级别和类别可以相同。
我想从该数组创建以下对象：

[
  { 
    category: 'A',
    children: [
      {
        level: 'Aa',
        children: [
          {
            sublevel: 'Aaa'
          },
          {
            sublevel: 'Aab'
          }
        ]
      },
      {
        level: 'Ab',
        children: [
          {
            sublevel: 'Abb'
          }
        ]
      }
    ]
  },
  { 
    category: 'B',
    children: [
      {
        level: 'Ac',
        children: [
          {
            sublevel: 'Abc'
}] }] }]

换句话说，如果有两个具有相同类别的对象并将其级别放入数组 children 中，我想将 category 合并为一个。如果还有相同类别和级别的对象，则将相同级别合并为一个，并将子级别放入相关数组children。

遍历数组并没有真正解决 [].map 和 [].reduce 以及各种循环。还尝试了 lodash mergeWith 和 deepmerge，但子关卡对它们来说似乎是不可见的。

在深度超过 2 层的条件下构造对象的优雅方法是什么？

Answer 1

你只需要一个在原始数组上嵌套 filter/map 的 reducer。

const categories = base.reduce((accumulator, data) => {
  let category;

  if (!accumulator.find(d => d.category === data.category)) {
    category = {
      category: data.category,
      children: [],
    };

    base
      .filter(d => d.category === data.category)
      .map(d => {
        if (!category.children.find(c => c.level === d.level)) {
          category.children.push({ level: d.level, children: [] });
        }

        const level = category.children.find(c => c.level === d.level);

        if (!level.children.find(c => c.sublevel === d.sublevel)) {
          level.children.push({ sublevel: d.sublevel });
        }
      })


    accumulator.push(category);
  }

  return accumulator;
}, []);

按超过 2 层深的条件合并嵌套对象

Merging nested objects by conditions more than 2 levels deep

javascript

nested-loops

javascript-objects