从嵌套分类数据中提取并展平指定子节点教程

const data = [
  {
    name: "Car",
    id: "19",
    count: "20",
    depth: "1",
    children: [
      {
        name: "Wheel",
        id: "22",
        count: "3",
        depth: "2",
        children: [
          {
            name: "Engine",
            id: "101",
            count: "1",
            depth: "3",
            children: [
              {
                name: "Engine and Brakes",
                id: "344",
                count: "1",
                depth: "4",
                children: []
              }
            ]
          }
        ]
      }
    ]
  },
  {
    name: "Bike",
    id: "3",
    count: "12",
    depth: "1",
    children: [
      {
        name: "SpeedBike",
        id: "4",
        count: "12",
        depth: "2",
        children: []
      }
    ]
  }
];

interface Category {
  name: string;
  id: string;
  count: string;
  depth: string;
  children: Category[];
}

// 辅助函数：将完整分类对象映射为精简对象
const mapCategory = (category: Category) => ({
  name: category.name,
  id: category.id,
  count: category.count,
});

/**
 * 从嵌套分类数据中提取并展平指定ID的子节点。
 *
 * @param categoryIds 目标分类ID数组。如果为空，则返回所有顶级分类及其直接子节点。
 * @param categories 完整的分类数据数组。
 * @returns 展平后的子节点列表。
 */
const getCategoriesChildren = (
  categoryIds: Category['id'][],
  categories: Category[],
): Pick<Category, 'id' | 'count' | 'name'>[] => {
  const foundChildren: Pick<Category, 'id' | 'count' | 'name'>[] = [];

  // 情况1: 如果没有指定任何分类ID，返回所有父节点及其直接子节点
  if (categoryIds.length === 0) {
    return categories.reduce<Pick<Category, 'id' | 'count' | 'name'>[]>(
      (acc, category) => {
        acc.push(mapCategory(category)); // 添加父节点
        acc.push(...category.children.map(mapCategory)); // 添加直接子节点
        return acc;
      },
      [],
    );
  }

  // 情况2: 处理指定分类ID的子节点提取
  // 栈用于迭代遍历所有分类，并追踪是否为目标ID的后代
  const stack: (Category & { isDesired?: boolean })[] = [...categories];

  while (stack.length) {
    const category = stack.pop(); // 从栈顶取出分类
    if (!category) continue; // 确保分类存在

    // 判断当前分类是否是期望的分类（即其ID在categoryIds中，或者它是某个期望分类的后代）
    const isDesiredCategory =
      categoryIds.includes(category.id) || category.isDesired;

    // 如果是期望分类，则将其所有直接子节点添加到结果列表中
    if (isDesiredCategory) {
      foundChildren.push(...category.children.map(mapCategory));
    }

    // 将当前分类的子节点推入栈中，继续遍历
    // 如果当前分类是期望分类，则其子节点也应被标记为 isDesired: true
    stack.push(
      ...(isDesiredCategory
        ? category.children.map((child) => ({ ...child, isDesired: true }))
        : category.children),
    );
  }

  return foundChildren;
};

// 示例数据
const data = [/* ...同上 */];

// 情况1: 没有指定分类ID，获取所有父节点及其直接子节点
const defaultResult = getCategoriesChildren([], data);
console.log('默认结果:', defaultResult);
/*
[
  { name: "Car", id: "19", count: "20" },
  { name: "Wheel", id: "22", count: "3" },
  { name: "Bike", id: "3", count: "12" },
  { name: "SpeedBike", id: "4", count: "12" }
]
*/

// 示例数据
const data = [/* ...同上 */];

// 情况2: 指定分类ID，获取其所有子节点
const specificIdsResult = getCategoriesChildren(['22', '3'], data);
console.log('指定ID结果:', specificIdsResult);
/*
[
  { name: "Engine", id: "101", count: "1" },
  { name: "Engine and Brakes", id: "344", count: "1" },
  { name: "SpeedBike", id: "4", count: "12" }
]
*/

// 情况3: 指定ID但该分类无子节点
const noChildrenResult = getCategoriesChildren(['4'], data); // SpeedBike 的 ID 是 '4'，它没有子节点
console.log('无子节点结果:', noChildrenResult); // 预期输出: []
/*
[]
*/

// 进一步测试：指定一个不存在的ID
const nonExistentIdResult = getCategoriesChildren(['999'], data);
console.log('不存在ID结果:', nonExistentIdResult); // 预期输出: []
/*
[]
*/