业务开发中tree树数据经常打交道，经常需要用到递归去操作更改数据。
现在遇到一个后台传给你一个某个位置的id值且需要你向上一层一层获取数据的值，这个时候你就需要反向递归去获取数据。
记录一次才坑经历吧

思路1
之前是想把源数据转成json字符串去查找，这样性能应该能更好，少了很多循环操作。后面发现自己正则似乎太菜了学的都还给老师了无奈只好放弃这种方法，

思路2
正常递归源数据数组 判断children值以及使用数组的some方法判断是否需要继续递归下去还是从头递归；
贴代码

	// 反递归查找
    function formTree(list, id) {
      // const st = JSON.stringify(props.treeData);
      // st.lastIndexOf(`"id":${props.deptId}`)
      list.forEach(item => {
        if (item.children && item.children.length) {// 判断是否有children子集
          if (item.children.some(row => row.id === id)) {// 判断子集里是否有想要的值来进行是否需要继续递归还是从头递归
            treeId.value.push(item.id);// 接收符合的数据id
            formTree(props.treeData, item.id) // 从头递归
          } else formTree(item.children, id) // 继续递归
          
        } else return
      })
    }


	watchEffect(() => {
      visible.value = props.showModal;
      if (props.showModal) {// modal弹窗状态
        if (props.deptId && props.treeData) {// props.deptId源数组某一处的id  props.treeData源数组数据
          treeId.value = []; // 接收id的数组
          treeId.value.push(props.deptId);
          formTree(props.treeData, props.deptId);// 递归
        }
      }
	})

以上 treeId.value里就是想要的id值合集

如果有更好的方法思路可以带带弟弟哦

有啥补充请大神们在下面留言：

//反向递归   找到最低层的菜单一步步往上查    （先逆向递归然后再反向递归）

  [HttpPost]

        public ReturnNode MenuListByAdd(GetMenuListInput input)
        {
            /反向递归，从最底层menu找上面所有的menu
            var allList = dbContext.yf_menu.AsQueryable().ToList();
            string sql = "select * from  yf_menu as d where  d.Id  in(select menuid from yf_action as c where c.id in(select a.actionid from  yf_role_action as a where a.roleid = 2) GROUP BY  menuid); ";
            var bottomList = dbContext.Database.SqlQuery<yf_menu>(sql).ToList();
            List<yf_menu> newList = new List<yf_menu>();
            foreach (yf_menu node in bottomList)
            {
                newList.Add(node);
                newList.AddRange(GetParentMenuList(node, allList));
            }
            var list = newList.Where((x, i) => newList.FindIndex(z => z.id == x.id) == i);//数组去重


            ///************************
            string actionSql = string.Format("SELECT a.*,r.roleid from yf_action a LEFT JOIN yf_role_action r on  a.id=r.actionid and r.roleid={0}", input.roleId);
            var actionList = dbContext.Database.SqlQuery<GetMenuListActionOutput>(actionSql).ToList();
            var newlist = new List<GetMenuListOutput>();
            foreach (yf_menu menu in list)
            {
                GetMenuListOutput newinput = new GetMenuListOutput();
                newinput.createtime = menu.createtime;
                newinput.id = menu.id;
                newinput.menuname = menu.menuname;
                newinput.menuurl = menu.menuurl;
                newinput.note = menu.note;
                newinput.parentid = menu.parentid;
                newinput.actionList = actionList.Where(u => u.menuid == menu.id).OrderBy(p => p.id).ToList();
                newlist.Add(newinput);
            }
            if (input.outDataType == 1)//树形
            {
                GetMenuListOutput tree = initMenuTree(newlist.Where(u => u.parentid == 0).FirstOrDefault(), newlist);
                return ReturnNode.ReturnSuccess(tree);
            }
            else if (input.outDataType == 2)//数据字典
            {
                return ReturnNode.ReturnSuccess(newlist.ToDictionary(u => u.id));
            }
            else//数组
            {
                return ReturnNode.ReturnSuccess(newlist);
            }

        }

//递归找上级方法

   //递归找上级
        private List<yf_menu> GetParentMenuList(yf_menu menuNode, List<yf_menu> allList)
        {
            yf_menu parentNode = allList.Where(u => u.id == menuNode.parentid).FirstOrDefault();
            List<yf_menu> newList = new List<yf_menu>();
            newList.Add(parentNode);
            if (parentNode.parentid != 0)
            {
                newList.AddRange(GetParentMenuList(parentNode, allList));
            }
            return newList;
        }

==========正向递归

 //生成树
        private GetMenuListOutput initMenuTree(GetMenuListOutput menu, List<GetMenuListOutput> list)
        {
            var chirldens = list.Where(u => u.parentid == menu.id);
            menu.childrens = new List<GetMenuListOutput>();
            foreach (var node in chirldens)
            {
                var newnode = initMenuTree(node, list);
                menu.childrens.Add(newnode);
            }


            return menu;
        }

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

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