nodejs 平面数据转换成树形结构

不知道算不算递归函数，想写递归又憋不出来，目前只能做出来两层的树形结构

一、处理成两层树形

先处理两层，第三层数据日后再做。

 要处理的数据如下：

const items = [
    { id: 1, parentId: null, name: 'Item 1' },
    { id: 2, parentId: 1, name: 'Item 1.1' },
    { id: 3, parentId: 1, name: 'Item 1.2' },
    { id: 4, parentId: 2, name: 'Item 1.1.1' },
    { id: 5, parentId: null, name: 'Item 2' }
  ];

处理的方法：

function find(id,params) {
    var arry = []
    for (let i = 0; i < params.length; i++) {
      const element = params[i]
      if (!element.parentId) {
        element.children = []
        id = element.id
        arry.push(element)
      }
      childr(id,element，params)
    }
    return arry
  }
  function childr(id,list，params) {
    if(list.parentId == id){
      var ids = id-1
      // console.log("level2",list,id)
      items[ids].children.push(list)
    }
  }
  var tree = find(0,items)
    console.log(tree)

我的思路是：先遍历 if判断根节点，在根节点下面添加children[]存放子节点，不是根节点传递pid匹配到根节点然后存放到children中。

代码详解：

第一步：find（）函数就是将所要处理的数据（items）中的根节点遍历出来然后加上children数组进行存放子节点，这里的id的id取的是items中的id，其实直接取每个map的index会比较好。新建一个数组存放各个根节点，最后将这个数组返回。

第二步：在遍历过程中会将子节点也遍历出来，用chidr()函数处理子节点将子节点按照对应的层级存放到根节点中。

最终效果：

[
[0]   {
[0]     id: 1,
[0]     parentId: null,
[0]     name: 'Item 1',
[0]     children: [ [Object], [Object] ]
[0]   },
[0]   { id: 5, parentId: null, name: 'Item 2', children: [] }
[0] ]

二、处理成多层

来源：问AI问出来的

处理的数据：

const items = [
      { id: 1, parentId: null, name: 'Item 1' },
      { id: 2, parentId: 1, name: 'Item 1.1' },
      { id: 3, parentId: 1, name: 'Item 1.2' },
      { id: 4 ,parentId: 6, name: 'item 2.1'},
      { id: 5, parentId: 2, name: 'Item 1.1.1' },
      { id: 6, parentId: null, name: 'Item 2' },
    ];

方法：

function listToTree(list) {
      let map={} ,node , tree=[],i;
      for (let i = 0; i < list.length; i++) {
        map[list[i].id] = i
        list[i].children = []
        // console.log("初始化映射：", map)
        // console.log("添加children：",list)
      }
      console.log(map)
      for (let i = 0; i < list.length; i++) {
        node = list[i]
        if(!node.parentId){
          tree.push(node)
        }else{
          list[map[node.parentId]].children.push(node)
          
          console.log("??",list[map[node.parentId]] , node.parentId,map[node.parentId])
        }
      }
      return tree
    }
    var trees = listToTree(items)
    //console.log('树形结构：',trees)

第一步：先做一个映射的关系，把平面数据中的id和它的索引做成映射关系，以及把平面数组中的每一个节点都加上children数组；最终map打印的数据是: { '1': 0, '2': 1, '3': 2, '4': 3, '5': 4, '6': 5 },key对应的是items.id ,value对应的是index(索引)；

第二步：对list数据进行处理，for循环遍历的过程中进行if判断，如果parentId是null的话就是根节点了，反之是子节点。list[map[node.parentId]]：node.parentId 是遍历过程中其中一个非根节点的id，map[node.parentId]在map映射中找到对应的索引，在通过该索引确定在哪个节点下面。

最终返回数据：

 [
        {
            "id": 1,
            "parentId": null,
            "name": "Item 1",
            "children": [
                {
                    "id": 2,
                    "parentId": 1,
                    "name": "Item 1.1",
                    "children": [
                        {
                            "id": 5,
                            "parentId": 2,
                            "name": "Item 1.1.1",
                            "children": []
                        }
                    ]
                },
                {
                    "id": 3,
                    "parentId": 1,
                    "name": "Item 1.2",
                    "children": []
                }
            ]
        },
        {
            "id": 6,
            "parentId": null,
            "name": "Item 2",
            "children": [
                {
                    "id": 4,
                    "parentId": 6,
                    "name": "item 2.1",
                    "children": []
                }
            ]
        }
    ]