let arr = [{
                id: 1,
                name: '部门1',
                pid: 0
            },
            {
                id: 2,
                name: '部门2',
                pid: 1
            },
            {
                id: 3,
                name: '部门3',
                pid: 1
            },
            {
                id: 4,
                name: '部门4',
                pid: 3
            },
            {
                id: 5,
                name: '部门5',
                pid: 4
            },
        ]

如上一个数据结构，将他转为树形结构。
方法一：

         function queryChilrden(arr) {
            let result = []
            arr.forEach(s => {
                s.chilrden=[]
                arr.forEach(d=>{
                    if(s.id==d.pid){
                        s.chilrden.push(d)
                    }
                })
                })
            return arr.find(item => item.pid === 0)
         }

解析：
遍历两次原数组，并在第一次遍历的时候给数组的每一项添加一个chilrden属性。在第二次遍历的时候就开始比较，用本身id去比对每一项的pid。如果相等，即说明找到了儿子，那就将其push进自身的chilrden数组里。最后return的时候做个筛选，返回最高等级的也就是pid为0的那一项。

方法二：

function mapFun(arr){
            let mapItem = {}
            let result = []
            arr.forEach(d=>{
                mapItem[d.id] ={...d,chilrden:[]}
            })
            arr.forEach(s=>{
                if(!s.pid){
                    result.push(mapItem[s.id])
                }else{
                    if(mapItem[s.pid]){
 //用s.pid为key去mapItem里找，如果找到了。就说明当前这一项在mapItem里有父亲，然后就用父亲将当前s push进去。
                        mapItem[s.pid].chilrden.push(mapItem[s.id])
                    }
                }
            })
            return result
        }

解析：第二种方法其实很第一种方法雷同，但是第二种方法用到了map结构。首先准备一个mapItem的对象，用来存放所有数据。
第一次遍历，将数组里的数据转成map结构存入mapItem对象中。其实就是将每一项的id作为key，这样会方便后面查找数据。提高效率

第二次遍历的时候就要开始找数据了。首先把pid为0的拎出来，找到元素之后要注意，这里不再是存储遍历中的数据。而是通过遍历中的数据去找对应的map数据，将map数据存起来。
可以理解为mapItem就是一本字典。比如我们要找pid为0的那一项。找到了之后，在mapItem这本字典中用当前项的id作为key，就可以找到这个元素
要记住存的时候要用对象的id去mapItem里找，而不是用对象的pid去找。因为我们在存mapItem的时候用的是对象的id为key

                    if(mapItem[s.pid]){
                        mapItem[s.pid].chilrden.push(mapItem[s.id])
                    }

在mapItem中key是每一项的id。已知，元素的pid等于父亲的id。所以这里用mapItem[s.pid]去找父亲。如果存在，那就说明当前遍历到的这一个元素，有父亲。所以就将当前元素push进去。push的时候注意，不再是用pid去找元素了，而是用id了。因为我们push是要push元素本身，而不是再去找他父亲

方法三：

// 递归
const toTree = (items, id = null, link = 'parentId') =>
  items
  .filter(item => item[link] == id)
  .map(item => ({
    ...item,
    children: toTree(items, item.id)
  }));

解析：通过数组的filter方法过滤出所有的父级，然后遍历父级这个数组，让他的children属性继续去递归调用这个函数。