按超过 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'
}] }] }]

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

使用[].map 和[].reduce 以及各种循环，遍历数组并没有真正奏效。还尝试了 lodash mergeWith 和 deepmerge，但子级别似乎对它们不可见。

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

Answer 1

您只需要一个在原始数组上带有嵌套过滤器/映射的 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;
}, []);