数组对象的数据格式，转化为树形结构，怎么转？

Question

现有如下数据：

var init_data = [
  {
    "parent_ind":"女装",
    "name":"连衣裙"
  },
  {
    "parent_ind":"女装"
  },
  {
    "parent_ind":"女装",
    "name":"半身裙"
  },
  {
    "parent_ind":"女装",
    "name":"A字裙"
  },
  {
    "name":"数码"
  },
  {
    "parent_ind":"数码",
    "name":"电脑配件"
  },
  {
    "parent_ind":"电脑配件",
    "name":"内存"
  },
];

要转化为下面的树形结构：

{
  "数码":{
    "电脑配件":{
      "内存":{}
    }
  },
  "女装":{
    "连衣裙":{},
    "半身裙":{},
    "A字裙":{}
  }
}

求函数怎么写？

Answer 1

function convert2tree(data) {
    var store = {};
    var result = {};

    data.forEach(item => {
        if (item.hasOwnProperty('name')) {
            if (item.hasOwnProperty('parent_ind')) {
                var name = item.name;
                var parent_ind = item.parent_ind;

                if (store[parent_ind]) {
                    if (!store[name]) {
                        store[name] = `${store[parent_ind]}-${name}`;
                    }
                } else {
                    store[parent_ind] = parent_ind;
                    store[name] = `${parent_ind}-${name}`;
                }
            } else {
                var name = item.name;

                if (!store[name]) {
                    store[name] = name;
                }
            }
        }
    });

    Object
    .entries(store)
    .sort((a, b) => [...a[1].matchAll('-')].length - [...b[1].matchAll('-')].length)
    .forEach(([key, value]) => {
        if (value.includes('-')) {
            var target = result;
            var ks = value.split('-');

            for (let i = 0, len = ks.length; i < len; i++) {
                if (i < len - 1) {
                    target = target[ks[i]];
                } else {
                    target[ks[i]] = {};
                }
            }
        } else {
            result[key] = {};
        }
    });

    return result;
}

Answer 2

function transformTree(arr) {
  let result = {};
  const newValue = arr.filter(item => item.parent_ind && item.name)
  newValue.forEach(item => {
    if (result[item.parent_ind]) {
      result[item.parent_ind][item.name] = {}
    } else {
      result[item.parent_ind] = {};
      result[item.parent_ind][item.name] = {}
    }
  })
  return result;
}

demo 链接：https://codepen.io/liangxh052...

Answer 3

function format(data){
    let res = {};
    let nameBasedParent = [];
    data.map(val=>{
        if( val.parent_ind && val.name && nameBasedParent.indexOf(val.name)<0 ){
            nameBasedParent.push(val.name);
        }   
        return val             
    }).map(val=>{
        if(
            !res[val["parent_ind"]] 
            && val["parent_ind"] 
            && nameBasedParent.indexOf(val["parent_ind"])==-1
        ){
            res[val["parent_ind"]]={};
        }
        return val;
    }).filter(val=>val.parent_ind && val.name)
    .map(val=>{
        if( nameBasedParent.indexOf(val.parent_ind)==-1 ){
            res[val.parent_ind][val.name]={}
        }
        else if(nameBasedParent.indexOf(val.parent_ind)!=-1){
            data.forEach(item=>{
                if(item.name == val.parent_ind){
                    res[item.parent_ind][item.name][val.name]={}
                }
            })
        }
    })

    console.log(res);
    return res;
}

我自己写的，个人感觉就是太麻烦，循环比较多，而且数据变化的话（比如init_data里面再多加一项 {"parent_ind":"内存","name":"金士顿"}），这个函数就不行了，有没有更好的办法做成通用的函数。

Answer 4

看样子是循环加递归