Javascript-基于边缘条件从数组创建嵌套对象

递归每次都会让我感到痛苦

我有以下数组：

fooArray: Foo[] = 
[
  { foo: "a", indent: 0 },
  { foo: "b", indent: 1 },
  { foo: "c", indent: 2 },
  { foo: "d", indent: 1 },
  { foo: "e", indent: 2 },
  { foo: "f", indent: 2 },
  { foo: "g", indent: 1 },
  { foo: "h", indent: 0 },
]

我想将其映射到不同类型的对象（TS），并根据其缩进值嵌套对象，如下所示：

interface Bar {
  foo: string,
  bar?: Bar[]
}

barArray: Bar[] = 
[
  { 
    foo: "a", 
    bar: [
      { foo: "b",
        bar: [{ foo: "c" }],
      { foo: "d",
        bar: [
          { foo: "e" }, 
          { foo: "f"}
        ] 
      },
      {
        foo: "g"
      }
    ]
  },
  { foo: "h" }
]

---

我一直试图搞乱减缩器，但需要根据相邻数组成员确定递归的级别真是让我头疼。如果有人有任何想法，我们将不胜感激

我的解决方案完全是一项正在进行的工作，所以请不要测试或尝试它。我不得不离开一会儿，想把这件事留在这里，以后再谈：

let fooArray=[
{foo:“a”，缩进：0}，
{foo:“b”，缩进：1}，
{foo:“c”，缩进：2}，
{foo:“d”，缩进：1}，
{foo:“e”，缩进：2}，
{foo:“e1”，缩进：1}，
{foo:“e2”，缩进：0}，
{foo:“e3”，缩进：1}，
{foo:“f”，缩进：2}，
{foo:“g”，缩进：1}，
{foo:“h”，缩进：0}，
];
//设barArray=fooArray.slice（）.flatMap（（e，i，a）=>i？null:Array（a.filter（f=>！f.indent）.length.fill（）.map（（f，j，b）=>a.splice（0，Math.max）（a.slice（1.findIndex（g=>g.indent==0）+1））；
//WIP//let barArray=fooArray.slice（）.flatMap（（e，i，a）=>i？null:Array（a.filter（f=>！f.indent）.length）.fill（）.map（（f，j，b）=>a.splice（0，Math.max（a.slice（1）.findIndex（g=>g.indent==0）+1,1））.map（e=>e.map（（f，i，a）=>a[i+1]？.indent>f.indent？{foo:f.foo，bar:a.splice=1]）；
//（e，i，a）的平面图（（e，i，i，a）的（（e，i，i，a）=>i？i？null：数组（a.过滤器过滤器（f=>！f.defind.长度）2//让Bararrararay=Foo5.5）2//放任制造制造业者）2//2//放任制造制造业者（let.5）2//放任制造业者）的）3）3.平面图（e，3）平面图（e，3）平面图（（e，i，i，i，i，i，i，i，i，i，i，i，a，i，i，i，i，i，i，a，a，a，a，i，i，a，a，i，i，a，a，a，i，i，a，a，i，a，a，a，i，i，i，a，i，a，a，i，a，a，a，i，i，i，i，a/a[i+1]？.indentf.reverse（））；
//WIP#3//let barArray=fooArray.slice（）.map（e=>（{…e}））.flatMap（（{，i，a）=>i？null:Array（a.filter（e=>！e.indent.length）.fill（）.map（e=>a.splice（0，Math.max）（a.slice（1）.findIndex（f=>f.indent==0 max）+1,1））.map（e=>e.length>1？e.flatMap（（e，i）>i？null:Array（e.filter）（e.filter.max）（a.slice（a.slice）（f=>findIndex）（f=>max）+.indent.f=>0.filter.filler.fill（））.f=>0）map（e.slice（1）.findIndex（g=>g.indent==0）+1,1））：e）；
//简单获取对象//let barArray=fooArray.slice（）.map（e=>（{…e}））.flatMap（（{，i，a=>i？null:Array（a.filter（e=>！e.indent）.length.fill（）.map（e=>a.splice（0，Math.max）（a.slice（1.findIndex）（f=>f.indent==0）+1））；
//新在制品
fooArray.slice（）.map（e=>（{…e}））.flatMap（{，i，a=>i？null:Array（a.filter（e=>！e.indent.length）.fill（）.map（e=>a.splice（0，Math.max（a.slice（1）.findIndex（f=>f.indent==0）+1,1））.map（e=>e.length>1？{foo:e[0].foo，bar:e.slice（1）}:e[0]）
.map（a=>a.bar？
（（a.bar=a.bar.reverse（）.flatMap（（e，i）=>
a、 bar.findIndex（（f，j）=>j>i&e.indent！==f.indent）！=-1？
（a.bar.find（（f，j）=>j>i&e.indent！==f.indent）.indent>e.indent？e:（a.bar.find（（f，j）=>j>i&e.indent！==f.indent）.bar=a.bar.拼接（i，a.bar.findIndex（（f，j）=>i&e.indent！==f.indent）））
：e
).reverse（）），a）
：a
)
console.log（barArray）；

我们可以使用数组方法非常接近。它是否始终是缩进级别中获取

bar

属性的“最后”项（例如

foo:a，bar…

和

foo:c，bar…

）。您的所有项目一次最多只能增加或减少一个缩进。它会跳转超过一个缩进（1）吗➞ 3.➞ （5等）？一次只能跳转一个。如果不跳转，我将确保边缘条件仅是缩进是否更大，从而导致添加条。不，在一个foo列表中可能有多个条。我将尝试添加更多条，以澄清原始问题。我将使用array.sp和递归减缩器更接近解决方案虱子。当我接近时，我会发布我所拥有的。是的，请添加。我将留下我半成品的答案，稍后再回来。谢谢你的帮助！我可能会尝试使用你的一些想法来让我的答案更坚实。我最后只写了一个for循环，它将循环缩进时间并设置当前的“节点”到数组的最后一个栏。只要缩进只增加1就可以工作。@jmroon sweet！你能在这里发布最终结果供我测试吗？当然，我明天会发布。我需要对其进行Foobarise处理。：p它不是特别优雅，但可以工作。