萌新求助，数组转树结构

Question

       var origin = [
            'home/a/2019-04-09/1.txt',
            'home/a/2019-04-10/2.txt',
            'home/c/2019-04-09/3.txt',
            'home2/d/2019-04-09/4.txt',
            'home2/e/2019-04-09/5.txt'
        ];
        
       //输出
       var result = [{
            label: 'home',
            children: [
                {
                    label: 'a',
                    children:[
                        {
                        label:'2019-04-09',
                        children:...    
                        },
                        {
                        label:'2019-04-10',
                        children:...    
                        },
                    ]
                  },
                {
                    label: 'c',
                    children:...
                  },
            ]
        },
        {
            label: 'home2',
            children: [
                {
                    label: 'b',
                    children:...
                  },
                {
                    label: 'e',
                    children:...
                  }
            ]
        }

        ] 
            
            
        折腾了一晚上 实在没想好怎么搞， 求大佬们帮助下我，感谢。
        

Answer 1

origin.map(p => p.split('/')).reduce((output, path) => {
  path.reduce((parent, child) => {
    if (parent && !parent.children) {
      parent.children = [{ label: child }]
      return parent = parent.children[0]
    }
    let container = parent ? parent.children : output
    parent = container.find(c => c.label === child)
    if (!parent) {
      parent = { label: child }
      container.push(parent)
    }
    return parent
  }, null)
  return output
}, [])

Answer 2

手机答题，姑且说下思路。

1. 一个切入点是字符串数据结构。字符串可以通过索引访问字符，比如var strDemo = 'mw5209';，那么strDemo[0]就是字符'm'，以此类推，strDemo[3]就是字符'2'。同时，字符串也会有length属性，有总长可以索引访问那就构建for循环呗，循环里放个变量，每次取一个字符，不是斜线就存到变量里，是斜线就把变量里的东西拿出来构建一级子树，同时变量清空继续，直到遍历完成，最后别忘记把变量里的东西拿出来收个尾就行了。
2. 另一个切入点，String 标准库有.split()方法，你把字符串视为以斜线分割的数组，有数组了那把成员挨个拿出来构建子树呗。
3. 还有个点是正则，不过这个需求不强求吧。

Answer 3

let origin = [
        'home/a/2019-04-09/1.txt',
        'home/a/2019-04-10/2.txt',
        'home/c/2019-04-09/3.txt',
        'home2/d/2019-04-09/4.txt',
        'home2/e/2019-04-09/5.txt'
    ];
    let res=[];
    function find(arr,value) {
        let flag=-1;
        arr.map((child,key)=>{
            if(child.label===value){
                flag=key;
            }
        })
        if(flag>-1) return arr[flag];
        arr.push({label:value,children:[]});
        return arr[arr.length-1];
    }
    origin.map((value)=>{
        let child=value.split('/');
        let g=find(res,child[0]);
        let g2=find(g.children,child[1]);
        find(g2.children,child[2]);
    })
    console.log(res);

Answer 4

        var origin = [
            'home/a/2019-04-09/1.txt',
            'home/a/2019-04-10/2.txt',
            'home/c/2019-04-09/3.txt',
            'home2/d/2019-04-09/4.txt',
            'home2/e/2019-04-09/5.txt'
        ];

        function loopChild(step, parentName) {
            var result = origin.reduce(function (arr, val) {
                var temp = val.split('/');
                if (step + 1 > temp.length) return arr;
                var current = GetNextPath(step, val);
                if (current == (parentName || "")) {
                    if (arr.filter(s => s.lable == temp[step]).length == 0) {
                        arr.push({
                            lable: temp[step],
                            children: loopChild(step + 1, GetNextPath(step + 1, val))
                        })
                    }
                }
                return arr;
            }, []);
            return result;
        }

        function GetNextPath(step, url) {
            var temp = url.split('/');
            var temp2 = [];
            for (var i = 0; i < step; i++) {
                temp2.push(temp[i]);
            }
            return temp2.join('/');
        }

Answer 5

  /**
   * 将一级的数据结构处理成树状数据结构
   * @param {Object} obj {key, pKey, data}
   *  @param obj.key  字段名称 比如id
   *  @param obj.pKey 父字段名称 比如 pid
   *  @param obj.rootPValue 根节点的父字段的值
   *  @param obj.data 需要处理的数据
   * @return {Array} arr
   */
  getTreeArr: (obj) => {
    if (!Array.isArray(obj.data)) {
      console.log('getTreeArr=>请传入数组')
      return []
    }
    let arr = obj.data, arr1 = []
    // 将数据处理成数状结构
    arr.forEach(item => {
      let index = 0
      item.children = []
      arr.forEach(item1 => {
        // 得到树结构关系
        if (item[obj.key] === item1[obj.pKey]) {
          item.children.push(item1)
        }
        // 判断根节点
        if (item1.id !== item.pid) {
          index++
        }
      })
      // 没传入根节点，根据当前数据结构得到根节点
      if (!('rootPValue' in obj) && index === arr.length) {
        arr1.push(item)
      }
    })
    // 传入根节点，根据传入的根节点组成树结构
    if ('rootPValue' in obj) {
      arr.forEach(item => {
        if (item[obj.pKey] === obj.rootPValue) {
          arr1.push(item)
        }
      })
    }
    return arr1
  }