树形数据转化为一维数组

现在有一组数据

const data =[
    {
      checked:'a',
      children:[
            {
              checked:'b1',
              children:[
                        {
                          checked:'c1',
                          storing:true,
                          children:[],
                            },
                        {
                          checked:'c2',
                          storing:true,
                          children:[],
                        },
                        {
                          checked:'c3',
                          storing:false,
                          children:[],
                        },
              ]
            },
            {
              checked:'b2',
              children:[
                        {
                          checked:'c1',
                          storing:true,
                          children:[],
                            },
                        {
                          checked:'c2',
                          storing:true,
                          children:[],
                        },
                        {
                          checked:'c3',
                          storing:false,
                          children:[],
                        },
                        ]
            },
            {
              checked:'b3',
              children:[{
                          checked:'c1',
                          storing:true,
                          children:[],
                            },
                        {
                          checked:'c2',
                          storing:true,
                          children:[],
                        },
                        {
                          checked:'c3',
                          storing:false,
                          children:[],
                        },]
            },
            {
              checked:'b4',
              children:[{
                          checked:'c1',
                          storing:true,
                          children:[],
                            },
                        {
                          checked:'c2',
                          storing:true,
                          children:[],
                        },
                        {
                          checked:'c3',
                          storing:false,
                          children:[],
                        },]
            }, 
        ]
    }
]

要转化为一个一维数组类似

const arr = [{keyA:a1,keyB:b1,keyC:c1,key4:true},{keyA:a1,keyB:b1,keyC:c2,key4:true}

]

就是把所有可能都弄出来，这个示例应该是12种结果

目前我自己想的方法是

this.treeDataToCompressed(this.checkedList);
//this.checkedList 为处理前数组
treeDataToCompressed(source) {
      source.forEach((cross) => {
        this.finalResult.push(cross.checked);
        if (cross.children && cross.children.length > 0) {
          this.treeDataToCompressed(cross.children);
        }
      });
    },


这样做第二次遍历的时候会直接跳过第一层 直接从第二次开始，有违初衷

用这个代码试试呢？

let arr = []
let level = 0

data.forEach(d => {
    let obj = {
        ['key' + level]: d.checked }
    checkChild(d, obj, level + 1)
})

function checkChild(d, obj, level) {
    if (d.children && d.children.length > 0) {
        d.children.forEach(s => {
            obj = { ...obj, ['key' + level]: s.checked }
            checkChild(s, obj, level + 1)
        })
    } else {
        arr.push(obj)
    }
}

console.log(arr.length, arr)

亲测有效，望采纳～～

key规则命名以key0,key1,key2依次类推，可以无限极，你一定要keyA，keyB这种的话自己定义一个数组keyMap=['A','B','C'...之类的]，但是数组长度一定要大于树的深度。。然后修改nitem中命名，这个应该很简单，自己弄下.key4不知道你根据哪个值得的。。是叶子节点的storing值？

//    const data = [       .....    ];//数据
    const arr = [];
    function buidArray(item, keys) {
        if (item.children == null || item.children.length == 0) {
            var nitem = {};
            for (var i = 0; i < keys.length; i++) nitem['key' + i] = keys[i];
            nitem['key' + i] = item.checked
            arr.push(nitem);
        }
        else {
            var isInit = !keys;
            if (isInit) keys = [item.checked];
            else keys.push(item.checked);

            for (var c of item.children) {
                buidArray(c, keys);
            }
            keys.pop();
        }
    }
    for (var item of data) buidArray(item);
    console.log(arr);

如下

      function treeDataToCompressed(source) {
        for (const i in source) {
          res.push({ ...source[i], children: [] });
          source[i].children && source[i].children.length > 0
            ? treeDataToCompressed(source[i].children)
            : ""; // 子级递归
        }

        return res;
      }
      treeDataToCompressed(data);
      console.log(res);

如有帮助请采纳回答 谢谢

const data =[
    {
      checked:'a',
      children:[
            {
              checked:'b1',
              children:[
                        {
                          checked:'c1',
                          storing:true,
                          children:[],
                            },
              ]
            },
        ]
    }
{
      checked:'b',
      children:[
            {
              checked:'b1',
              children:[
                        {
                          checked:'c1',
                          storing:true,
                          children:[],
                            },
              ]
            },
        ]
    }
]

比如这种就会出现六条数据

使用循环，递归来做