TypeScript实现递归获取父ID对应自身及所有子孙ID数组

实现思路 #

你现有的代码只做了单层遍历，没有对查询到的子节点递归查询其后代，补充递归逻辑即可实现需求，以下是符合要求的TypeScript实现：

基础实现（适合小数据量） #

首先定义数据结构类型：

interface GroupItem {
  groupId: number;
  parentGroupId: number | null;
}

const data: GroupItem[] = [
  { groupId: 1, parentGroupId: null },
  { groupId: 2, parentGroupId: 1 },
  { groupId: 3, parentGroupId: 1 },
  { groupId: 4, parentGroupId: null },
  { groupId: 5, parentGroupId: 99 },
  { groupId: 6, parentGroupId: 2 },
  { groupId: 7, parentGroupId: 6 },
  { groupId: 8, parentGroupId: 4 }
];

递归函数实现：

function getAllDescendantIds(arr: GroupItem[], targetId: number): number[] {
  // 校验目标ID是否存在，不存在直接返回空数组
  const isTargetExist = arr.some(item => item.groupId === targetId);
  if (!isTargetExist) return [];

  // 结果默认包含目标ID本身
  const result: number[] = [targetId];
  // 筛选所有直接子节点ID
  const directChildIds = arr
    .filter(item => item.parentGroupId === targetId)
    .map(item => item.groupId);
  
  // 先加入所有直接子ID，和示例输出顺序对齐
  result.push(...directChildIds);
  // 递归查询每个子节点的后代，加入结果（slice(1)是去掉已经加过的子节点本身）
  directChildIds.forEach(childId => {
    result.push(...getAllDescendantIds(arr, childId).slice(1));
  });

  return result;
}

测试调用：

console.log(getAllDescendantIds(data, 1)); // 输出 [1, 2, 3, 6, 7]

优化实现（适合大数据量） #

如果数据量较大，每次递归遍历全数组会影响性能，可以提前构建父ID到子节点的映射，减少重复遍历：

// 预构建父ID映射表
function buildParentMap(arr: GroupItem[]): Map<number | null, GroupItem[]> {
  const map = new Map<number | null, GroupItem[]>();
  arr.forEach(item => {
    if (!map.has(item.parentGroupId)) {
      map.set(item.parentGroupId, []);
    }
    map.get(item.parentGroupId)!.push(item);
  });
  return map;
}

function getAllDescendantIdsOptimized(arr: GroupItem[], targetId: number): number[] {
  const parentMap = buildParentMap(arr);
  const allGroupIds = new Set(arr.map(item => item.groupId));
  // 校验目标ID是否存在
  if (!allGroupIds.has(targetId)) return [];

  // 内部递归遍历方法
  const traverse = (id: number): number[] => {
    const result = [id];
    const children = parentMap.get(id) || [];
    children.forEach(child => {
      result.push(...traverse(child.groupId).slice(1));
    });
    return result;
  };

  return traverse(targetId);
}

测试调用：

console.log(getAllDescendantIdsOptimized(data, 1)); // 输出 [1, 2, 3, 6, 7]

内容的提问来源于stack exchange，提问作者user10426087