Javascript 从具有父子引用的数组创建树结构

我正在尝试将代码段中的json更改为树结构，就像中一样（下面是我期望的示例）。我知道它涉及递归，但我不知道如何深入地链接每一个

我期望的输出如下所示。父级为true的json将成为根。如果根具有值，则与值的id对应的json将被推送到带有json对象“data”的子数组中。同样，如果该json具有值，则对应于值id的json将被推送到具有json对象“数据”的子数组中，以此类推

我写的代码只是一个初始阶段。需要关于如何通过迭代完成嵌套的帮助

[
  {
    "data": {
      "parent": true,
      "id": "C001",
      "type": "Folder",
      "values": [
        {
          "id": "P001",
          "type": "File"
        }
      ]
    },
    "children": [
      {
        "data": {
          "parent": false,
          "id": "P001",
          "type": "File",
          "values": [
            {
              "id": "P002",
              "type": "Image"
            }
          ]
        },
        "children": [
          {
            "data": {
              "parent": false,
              "id": "P002",
              "type": "Image",
              "values": [

              ]
            }
          }
        ]
      }
    ]
  },
  {
    "data": {
      "parent": true,
      "id": "S000",
      "type": "Something",
      "values": [

      ]
    }
  }
]

var junkdata=[
{
“家长”：假，
“id”：“P001”，
“类型”：“文件”，
“价值观”：[
{
“id”：“P002”，
“类型”：“图像”
}
]
},
{
“父母”：对，
“id”：“C001”，
“类型”：“文件夹”，
“价值观”：[
{
“id”：“P001”，
“类型”：“文件”
}]
},
{
“家长”：假，
“id”：“P002”，
“类型”：“图像”，
“价值”：[]
},
{
“父母”：对，
“id”：“S000”，
“类型”：“某物”，
“价值”：[]
}];
var parentDatas=junkdata.filter（（x）=>x.parent==true）；
如果（ParentData.length>0）{
var finalResponse=parentDatas.map（（parentData）=>{
var resultJson={}；
resultJson.data=parentData；
if（parentData.values.length>0）{
resultJson.children=[]；
for（parentData.values的变量i）{
var child=junkdata.find（（x）=>x.id==i.id）；
如果（儿童）{
var jsonObj={}；
jsonObj.data=child；
resultJson.children.push（jsonObj）；
}
}
}
返回resultJson；
})
}
console.log（JSON.stringify（finalResponse））；

基本上，我们可以从这里开始处理根节点：

let tree = yourData.filter(x => x.parent).map(process);

其中，

process

是处理给定节点的递归函数：

let process = node => ({
    id: node.id,
    type: node.type,
    children: node.values.map(x => process(
        yourData.find(y => y.id === x.id)))
});

对于

node.values

中的每个

id

，它会找到一个具有该

id

的节点，并递归调用该节点上的

process

。处理完所有子节点后，

process

将它们收集到一个数组中，并返回新格式化的对象

这是处理类似于图的结构的通用递归模式，其中“节点”以某种方式连接到其他“节点”：

函数F（N:节点）{
对于连接到N的每个节点M{
F（M）基本上，我们可以从这里开始处理根节点：

let tree = yourData.filter(x => x.parent).map(process);

其中，
process
是处理给定节点的递归函数：

let process = node => ({
    id: node.id,
    type: node.type,
    children: node.values.map(x => process(
        yourData.find(y => y.id === x.id)))
});

对于
node.values
中的每个
id
，它会找到一个具有该
id
的节点，并递归调用该节点上的
process
。处理完所有子节点后，
process
将它们收集到一个数组中，并返回新格式化的对象

这是处理类似于图的结构的通用递归模式，其中“节点”以某种方式连接到其他“节点”：

函数F（N:节点）{
对于连接到N的每个节点M{
F（M）你的代码帮了我很大的忙。非常感谢！！！你的代码帮了我很大的忙。非常感谢！！！