js树形结构递归 常用函数

• 假设有如下树结构

const treeData = [
    {
      title: '1',
      id: '1',
      key: '1',
      children: [
        {
          title: '1-1',
          id: '2',
          key: '2',
          children: [
            {
              title: '1-1-1',
              id: '3',
              key: '3',
            },
          ],
        },
      ],
    },
    {
      title: '2',
      id: '2',
      key: '1',
      children: [
        {
          title: '2-1',
          id: '4',
          key: '4',
          children: [
            {
              title: '2-1-1',
              id: '5',
              key: '5',
            },
          ],
        },
      ],
    },
  ];

• 根据某一节点id 查询他的所有子孙节点并返回.

// 根据某一节点id  查询他的所有子孙节点并返回.
export function findSons(tree, nodeId) {
  for (let item of tree) {
    if (item.id === nodeId) {
      return item.children || [];
    } else if (item.children && item.children.length > 0) {
      let r = findSons(item.children, nodeId);
      if (r.length > 0) {
        return r;
      }
    }
  }
  return [];
}

• 根据某一节点id 递归查找父节点 与其自身 返回 ids 数组

// 根据某一节点id 递归查找父节点 与其自身  返回 ids 数组
export function findParents(tree, id) {
  for (let i in tree) {
    if (tree[i].id == id) return [tree[i].id];

    if (tree[i].children) {
      let node = findParents(tree[i].children, id);

      if (node !== undefined) return node.concat(tree[i].id);
    }
  }
}

• 根据keys 过滤节点 返回到res中

// 根据keys 过滤节点  返回到res中
export function rightTreeDataFilter(allTreeData, keys = [], res = []) {
  for (let item of allTreeData) {
    if (keys.includes(item.key)) {
      let one = { ...item };
      one.children = [];
      if (item.children && item.children.length > 0) {
        rightTreeDataFilter(item.children, keys, one.children);
      }
      res.push(one);
    }
  }
}

• 计算树结构的长度(所有子节点 + 父节点)

// 计算树结构的长度(所有子节点 + 父节点)
export function countLength(allTreeData, count) {
  for (let item of allTreeData) {
    count.number++;
    count.ids.push(item.id);
    if (item.children && item.children.length > 0) {
      countLength(item.children, count);
    }
  }
}

• 过滤树节点 不保留父节点

 // 过滤树节点 不保留父节点
export function filterTree(treeData, searchString) {
 // 创建一个空数组来存储结果
  let result = [];
  // 定义一个递归函数来遍历树
  function traverse(node) {
    // 检查当前节点的名称（或指定属性）是否包含搜索字符串
    if (node.title.includes(searchString)) {
      // 如果包含，则添加到结果数组中
      result.push(node);
    } else {
      // 遍历所有子节点
      if (node.children && node.children.length > 0) {
        node.children.forEach((child) => {
          traverse(child); // 递归调用
        });
      }
    }
  }

  // 从根节点开始遍历
  for (let item of treeData) {
    traverse(item);
  }

  // 返回结果
  return result;
}

• 过滤树节点 但保留父节点

 // 过滤树节点 但保留父节点
export function filterTreeAndFather(treeData, searchString) {
  // 辅助函数，用于递归检查节点和它的子树
  function checkNodeAndSubtree(node) {
    // 检查当前节点的title是否包含searchString
    if (node.title.includes(searchString)) {
      // 如果包含，则保留此节点，并递归检查其子节点
      // if (node.children) {
      //     node.children = node.children.filter(child => checkNodeAndSubtree(child));
      // }
      return true; // 返回true表示此节点或其子节点满足条件
    } else if (node.children) {
      // 尝试在子树中找到匹配的节点
      let hasMatchingChild = false;
      node.children = node.children.filter((child) => {
        const result = checkNodeAndSubtree(child);
        if (result) hasMatchingChild = true;
        return result;
      });
      // 如果子树中有匹配的节点，则返回true以保留此父节点
      return hasMatchingChild;
    }
    // 既没有匹配当前节点，也没有在子树中找到匹配的节点
    return false;
  }

  // 对树中的每个根节点调用辅助函数
  return treeData.filter((rootNode) => checkNodeAndSubtree(rootNode));
}