如何在javascript中动态地将带有数组的深层JS对象减少为没有数组的JS对象？

我有一个对象数组，每个对象都有一个id作为键。每个对象表示id的导航列表

我需要将所有导航列表合并到一个大列表中，其中叶包含所属ID

结果对象不应包含数组，而应包含作为ID列表的叶

我已经尝试过递归解决方案，像merge和assign这样的lodash函数，但我坚持使用对象的深度

输入JSON为，例如：

[
  {
    "id0": [
      {
        "Topitem 1": [
          {
            "Subitem 1": [
              "Leaf 1"
            ]
          }, {
            "Subitem 2": [
              "Leaf 2"
            ]
          }
        ]
      },
      {
        "Topitem 1": [
          {
            "Subitem 3": [
              "Leaf 1"
            ]
          }
        ]
      },
      {
        "Topitem 2": [
          "Leaf 1",
          "Leaf 3"
        ]
      },
      {
        "Topitem 3": [
          {
            "Subitem 1": [
              {
                "SubSubitem 1": [
                  "Leaf 4"
                ]
              }
            ]
          }
        ]
      }
    ]
  },
  {
    "id1": [
      "Leaf 5"
    ]
  },
  {
    "id2": [
      "Leaf 5"
    ]
  },
  {
    "id3": [
      {
        "Topitem 1": [
          "Leaf 1",
          {
            "Subitem 2": [
              "Leaf 2",
              "Leaf 3"
            ]
          }
        ]
      }, {
        "Topitem 2": [
          "Leaf 1",
          "Leaf 2"
        ]
      }
    ]
  },
  {
    "id4": [
      "Leaf 5"
    ]
  }
]

预期产出为：

{
  "Topitem 1": {
    "Subitem 1": {
      "Leaf 1": ["id0"]
    },
    "Subitem 2": {
      "Leaf 2": ["id0","id3"],
      "Leaf 3": ["id3"]
    },
    "Subitem 3": {
      "Leaf 1": ["id0"]
    },
    "Leaf 1": ["id3"]
  },
  "Topitem 2": {
    "Leaf 1": ["id0","id3"],
    "Leaf 2": ["id0","id3"]
  },
  "Topitem 3": {
    "Subitem 1": {
      "SubSubitem 1": {
        "Leaf 4": ["id0"]
      }
    }
  },
  "Leaf5": ["id1","id2","id4"]
}

---

您可以采取迭代和递归的方法，在第一次运行时使用一个独特的函数，在该函数中保存

id

，以便以后在数组中收集，然后对嵌套对象/键使用递归部分

给定数据结构的主要问题是，数组最后包含字符串而不是对象

函数转换（数组）{
函数iter（数组、对象、值）{
array.forEach（o=>{
如果（！o | | typeof o！=“object”）{
（对象[o]=对象[o]| |[]）。推送（值）；
返回；
}
对象
.条目（o）
.forEach（[k，v]）=>iter（v，object[k]=object[k]|{}，value））；
});
}
var result={}；
forEach（o=>Object.entries（o.forEach）（[k，v]）=>iter（v，result，k））；
返回结果；
}
变量数据=[{id0:[{“Topitem 1”：[{“子项1”：[“叶1”]}，{“子项2”：[“叶2”]}，{“Topitem 1”：[{“子项3”：[“叶1”]}]，{“Topitem 2”：[“叶1”，“叶3”}，{“Topitem 3”：[{“子项1”：[“叶4”]}]}}]}，{“子项1:[“叶5”}]，{“叶5”}，{“叶5”}，{子项1:{“叶1”}，{id1:{“叶5”}，{Topitem:{[“叶2”，“叶3”]}，{“顶项2”：[“叶1”，“叶2”]}，{id4:[“叶5”]}]；
console.log（转换（数据））；

.as控制台包装{max height:100%！important；top:0；}

这是一个使用and的解决方案。此解决方案不需要递归

//const objectScan=require（'object-scan'）；
//const lodash=需要（“lodash”）；
常量myObject=[{id0:[{'Topitem 1'：[{'Subitem 1'：['Leaf 1']}，{'Subitem 2'：['Leaf 2']}，{'Topitem 1'：[{'Subitem 3'：['Leaf 1']}，{'Topitem 2'：['Leaf 1'，'Leaf 3']}，{'Topitem 3'：[{'Subitem 1'：['SubSubSubSubSubSubSubItem 1'：['Leaf 4']}]}]}]}，{'Leaf 5']}，{'Leaf 5'.['Topitem 1']}，{'，{'子项2'：['Leaf 2'，'Leaf 3']}}，{'Topitem 2'：['Leaf 1'，'Leaf 2']}}，{id4:['Leaf 5']}；
const convert=（obj）=>objectScan（['**']{
filterFn:（{key，value，context}）=>{
如果（值的类型！=='string'）{
返回；
}
常量k=[…key.slice（2）.filter（（e）=>typeof e==='string'），value]；
const cur=lodash.get（上下文，k）；
如果（cur==未定义）{
set（上下文，k，[key[1]]）；
}否则{
电流推送（键[1]）；
}
}
})（obj，{}）；
console.log（convert（myObject））；
//=>{'Leaf 5'：['id4'，'id2'，'id1']，'Topitem 2'：{'Leaf 2'：['id3']，'Leaf 1'：['id3'，'id0']，'Leaf 3'：['id0']，'Leaf 3'：['id3']，'id0']，'Leaf 1'：['id3']，'Subitem 3'：['id3']，'Leaf 1'：['id0']，'id0']，'Leaf 1'：['id0']，'Topitem}，'{'subsubsubitem 1'：{'Leaf 4'：['id0']}}}}

。作为控制台包装{最大高度：100%！重要；顶部：0}