递归和递归返回值

递归

递归函数有一个基本条件，它100%接收一个函数，该函数的数据结构必定是一致的。
例如：有一个递归函数，遍历它所有的的数据，返回期望的数据结构
初始进入时，传入一个list，遍历list的所有数据，碰到dataType == 8的时候item有一个children，该children的结构与传入的list一样

// 递归函数
function dataLoop(list, num = null) {
      let group = list.map((item) => {
        if (item.dataType == 8) {
          return {
            id: item.id,
            sort: num === null ? item.sort : num,
            dataType: item.dataType,
            bigBoList: dataLoop(item.children, item.sort),
          };
        } else if (item.dataType == 7) {
          return {
            id: item.id,
            score: item.score,
            sort: num === null ? item.sort : num,
            scorePoint: item.scorePoint,
            dataType: item.dataType,
          };
        } else {
          return {
            id: item.id,
            score: item.score,
            sort: num === null ? item.sort : num,
            dataType: item.dataType,
          };
        }
      });
      return group;
    }

dataLoop(list);

你可以在递归函数里传入条件，然后根据条件进行特殊处理，但是有一个必须条件，初始的参数和递归传入的参数数据结构一致且一定存在。
在上面代码中，dataType == 8我传入了自身的sort，后续遍历的所有项都要按照传入的sort赋值，完成了特殊处理且不影响递归函数。

返回值

数据

let list = [
    {
        "pagerCategoryId": 26,
        "categoryName": "测试22",
        "parentId": 0,
        "level": 1,
        "sort": 1,
        "isShow": 1,
        "children": null,
        "value": 26,
        "label": "测试22"
    },
    {
        "pagerCategoryId": 25,
        "categoryName": "测试1",
        "parentId": 0,
        "level": 1,
        "sort": 2,
        "isShow": 1,
        "children": null,
        "value": 25,
        "label": "测试1"
    },
    {
        "pagerCategoryId": 1,
        "categoryName": "一级分组",
        "parentId": 0,
        "level": 1,
        "sort": 3,
        "isShow": 0,
        "children": [
            {
                "pagerCategoryId": 2,
                "categoryName": "二级分组",
                "parentId": 1,
                "level": 2,
                "sort": 2,
                "isShow": 0,
                "children": [
                    {
                        "pagerCategoryId": 29,
                        "categoryName": "三级分组-D",
                        "parentId": 2,
                        "level": 3,
                        "sort": 3,
                        "isShow": 1,
                        "children": null,
                        "value": 29,
                        "label": "三级分组-D"
                    },
                    {
                        "pagerCategoryId": 27,
                        "categoryName": "三级分组-B",
                        "parentId": 2,
                        "level": 3,
                        "sort": 4,
                        "isShow": 1,
                        "children": null,
                        "value": 27,
                        "label": "三级分组-B"
                    },
                    {
                        "pagerCategoryId": 28,
                        "categoryName": "三级分组-C",
                        "parentId": 2,
                        "level": 3,
                        "sort": 5,
                        "isShow": 1,
                        "children": null,
                        "value": 28,
                        "label": "三级分组-C"
                    },
                    {
                        "pagerCategoryId": 3,
                        "categoryName": "三级分组-A",
                        "parentId": 2,
                        "level": 3,
                        "sort": 6,
                        "isShow": 0,
                        "children": null,
                        "value": 3,
                        "label": "三级分组-A"
                    }
                ],
                "value": 2,
                "label": "二级分组"
            }
        ],
        "value": 1,
        "label": "一级分组"
    }
]

逻辑
通过给定的value，找到对应的项

// 级联选择
function paperTypeChange() {
  let item = loopFn(list, 2);
  // item 对应项value ===2
}
paperTypeChange()

// 递归查值
function loopFn(arr, val) {
  let item = null;
  if (!arr) return;
  for (let i = 0; i < arr.length; i++) {
    if (arr[i].value == val) {
      item = arr[i];
      break;
    } else {
      item = loopFn(arr[i].children, val); // 接收递归返回值
    }
  }
  return item;
}

在这个递归查值的过程中，由于是递归查询，每次结果都从loopFn函数返回
所以无论第一次遍历或n次遍历，都需要从loopFn函数接收返回值，这样才能获得正确结果
如果上面else分值item不接收返回值，那么最终返回的只是第一次层遍历结果 item === null