javascript - js数据处理转换？？

Question

var data1=[{
            "tid": "1",
            "text": "产品分析",
            "children": [{
                "tid": "1-1",
                "text": "模拟产品计划",
                "children": [{
                    "tid": "1-1-1",
                    "text": "用户行为分析1"
                }, {
                    "tid": "1-1-2",
                    "text": "用户行为分析2"
                }]
            }]

 var data2 = [
            {"tid": "1", "text": "产品分析"},
            {"tid": "1-1", "pid": "1", "text": "模拟产品计划"},
            {"tid": "1-1-1", "pid": "1-1", "text": "用户行为分析1"},
            {"tid": "1-1-2", "pid": "1-1", "text": "用户行为分析2"}
        ];

请问大神，这两种数据格式怎么互相转换？注意pid的增添！！！

Answer 1

var data=[{
    "tid": "1",
    "text": "产品分析",
    "children": [{
        "tid": "1-1",
        "text": "模拟产品计划",
        "children": [{
                    "tid": "1-1-1",
                    "text": "用户行为分析1"
                }, {
                    "tid": "1-1-2",
                    "text": "用户行为分析2"
                }]
        }] 
}];
            
var res = [];

function transform(arr,pid){
    arr.map(function(item){
        res.push({
            tid : item.tid,
            pid : pid,
            text : item.text
        });        
        item.children && item.children.length && transform(item.children , item.tid);
    });
}

transform(data);

console.log(res);

function buildTree(tree,node){
    if(!node.pid){
        delete node.pid;
        tree.push(node);
    }
    else{
        tree.map(function(item){
            if(item.tid == node.pid){
                delete node.pid;
                item.children = item.children || [];                
                item.children.push(node);
            }else{
                buildTree(item.children,node);
            }
        });
        
    }    
}

var data = [];

for(item of res){
    buildTree(data,item);
}

console.log(data)

Answer 2

转树形：
function createTree(data, arr, tid) {
    arr = arr || [];
    data.reduce(function(prev, item) {
        tid ? prev.push({
            tid: item.tid,
            isleaf: item.isleaf,
            pid: tid,
            text: item.text
        }) : prev.push({
            tid: item.tid,
            isleaf: item.isleaf,
            text: item.text
        });
        item.children ? createTree(item.children, arr, item.tid) : '';
        return prev
    }, arr)
    return arr
}


//转回去
function orgData(data, arr) {
    arr = arr || [];
    let hash = {};
    let index = 0;
    data.reduce(function(prev, item) {
        item.pid ? '' : (hash[item.tid] = ++index, prev.push({
            tid: item.tid,
            isleaf: item.isleaf,
            text: item.text
        }));
        if (hash[item.pid]) {
            prev[hash[item.pid] - 1].children ? prev[hash[item.pid] - 1].children.push(item) : prev[hash[item.pid] - 1].children = [item]
        } else {
            if (item.pid) {
                let tt;
                item.tid.split('-').forEach(function(num, i) {
                    tt ? tt['children'] ? tt['children'][num - 1] = tt['children'][num - 1] || item : (tt['children'] = [], tt['children'][num - 1] = item) : '';
                    tt ? tt = tt['children'][num - 1] : tt = prev[num - 1];
                });
            }
        }
        return prev;
    }, arr);
    return arr;
}

Answer 3

树形转为非树形很简单.
写一个递归判断如果children 不为空继续调用
每次返回一个对象数组, 把返回的数组contact, 最后输出总的数组集合

ps: 没有pid 建议给一个默认值

Answer 4

递归，传入child和pid就好了。。。

function flatten(data, pid){
  if(!data) return [];

  var { tid, text, children } = data;
  var result = [{ tid, text, pid }];

  if(children) {
    children.forEach(child=>{
      result = result.concat(flatten(child, tid));
    });
  }

  return result;
}

console.log(flatten(data1[0]));

Answer 5

function trans (parent, data) {
    var res = {
        tid: data.tid,
        text: data.text
    };
  
    parent && (res.pid = parent.tid);

    return !data.children ? [res] : [res].concat(walk(res, data.children));
}

function walk (parent, children) {
    return children.reduce(function (prev, next) {
        return prev.concat(trans(parent, next));
    }, []);
}


walk(null, data1);