JavaScript通过子节点的值反向获取其父级链条，递归寻找

有这样的需求：知道一个值在某个数组当中，但是不确定在哪一级，想把该值的父级链条找出来。

1、数组对象

let arr = [
        {
            "children" : [
                {
                    "children" : [
                        {
                            level:3,
                            name:'银杏纲'
                        },
                        {
                            "children" : [
                                {
                                    "children" : [
                                        {
                                            "children" : [
                                                {
                                                    level:6,
                                                    name:'苏铁属'
                                                },
                                            ],
                                            level:5,
                                            name:'苏铁科'
                                        },
                                    ],
                                    level:4,
                                    name:'苏铁目'
                                },
                            ],
                            level:3,
                            name:'苏铁纲'
                        },
                    ],
                    level:2,
                    name:'裸子植物门'
                },
                {
                    "children" : [
                        {
                            "children" : [
                                {
                                    "children" : [
                                        {
                                            "children" : [
                                                {
                                                    level:6,
                                                    name:'蔷薇属'
                                                },
                                            ],
                                            level:5,
                                            name:'蔷薇科'
                                        },
                                        {
                                            "children" : [
                                                {
                                                    level:6,
                                                    name:'无尾果属'
                                                },
                                            ],
                                            level:5,
                                            name:'蔷薇科'
                                        },
                                    ],
                                    level:4,
                                    name:'蔷薇目'
                                },
                            ],
                            level:3,
                            name:'双子叶植物纲'
                        },
                    ],
                    level:2,
                    name:'被子植物门'
                },
            ],
            level:1,
            name:'植物界'
        },
        {
            "children" : [
                {
                    level:2,
                    name:'古虫动物门'
                },
                {
                    "children" : [
                        {
                            level:3,
                            name:'鱼纲'
                        }
                    ],
                    level:2,
                    name:'脊索动物门'
                }
            ],
            level:1,
            name:'动物界'
        }
    ]

2、通过子节点的值反向获取其父级链条：递归寻找

    function getParent(item, childrens, v){
        let arrRes = [];
        if(item.name == v){
            arrRes.unshift(item);
            return arrRes
        }
        let shangyiji;
        let recursive = (parent, children, v) => {
            for(let j = 0, length = children.length; j < length; j++){
                let node = children[j];
                if(node.name == v){
                    arrRes.unshift(node);
                    if(Object.is(children, childrens)){
                        arrRes.unshift(item);
                        break
                    }
                    recursive(parent, parent.children, shangyiji.name);//找到了，再从顶级的children里面开始找目标值的父级的父级
                    break;
                } else {
                    let aa = !!node.children
                    if(!!node.children){
                        shangyiji = node;//记录上一级的节点，找到了的时候用
                        recursive(parent, node.children, v);//没找到，并且还有children，就继续往下找
                    }
                }
            }
            return arrRes;
        };
        arrRes = recursive(item, childrens, v);
        return arrRes;
    }

    //测试
    let typeTree;
    for(let i = 0; i < arr.length; i++){
        typeTree=getParent(arr[i], arr[i].children, "蔷薇科")
        if(typeTree.length>0){
            break;
        }
    }
    let nameTree = []
    typeTree.forEach(iType=>{
        nameTree.push(iType.name)
    })
    console.log({typeTree,nameTree});

3、控制台输出结果：

{
    nameTree: ["植物界", "被子植物门", "双子叶植物纲", "蔷薇目", "蔷薇科"],
    typeTree: [{...}, {...}, {...}, {...}, {...}]
}

4、数据结构

[参考链接]：https://blog.csdn.net/qq_36437172/article/details/87198122