如何实现嵌套评论的递归逻辑？基于Sequelize自关联模型的问询

首先得先完善你的Comment模型关联，因为目前只有子评论关联父评论的belongsTo，还需要添加父评论关联子评论的hasMany，这样才能方便查询子评论：

// 在Comment模型里添加这个关联
models.comment.hasMany(models.comment, { 
  as: "children", 
  foreignKey: "parentId",
  onDelete: "CASCADE" // 可选，父评论删除时自动删除子评论
});

接下来给你三种可行的实现方案，按性能和实用性排序：

方案1：内存中构建嵌套结构（推荐） #

这种方法只需要一次数据库查询获取该文章所有评论，然后在内存中通过映射关系构建嵌套层级，性能最优，尤其适合评论较多的场景：

router.get('/article/:id/comments', async (req, res, next) => {
  try {
    const articleId = req.params.id;
    // 一次性获取该文章的所有评论
    const allComments = await models.comment.findAll({
      where: { articleId },
      order: [['createdAt', 'ASC']] // 按评论时间排序，可选
    });

    // 1. 构建评论ID到评论对象的映射，同时给每个评论初始化children数组
    const commentMap = new Map();
    allComments.forEach(comment => {
      comment.dataValues.children = [];
      commentMap.set(comment.id, comment);
    });

    // 2. 筛选根评论，并把子评论挂载到对应的父评论下
    const rootComments = [];
    allComments.forEach(comment => {
      if (comment.parentId === null) {
        rootComments.push(comment);
      } else {
        const parentComment = commentMap.get(comment.parentId);
        if (parentComment) {
          parentComment.children.push(comment);
        }
      }
    });

    res.json(rootComments);
  } catch (err) {
    next(err); // 把错误传给错误处理中间件
  }
});

优点：仅1次数据库查询，内存处理速度快；缺点：如果评论量极大（比如上万条），内存占用会略高，但一般业务场景完全够用。

方案2：递归查询子评论 #

这种方法先获取根评论，然后对每个根评论递归查询其子评论，适合评论层级不多、数量较少的场景：

// 定义递归函数，给单个评论添加子评论
async function attachChildren(comment) {
  const children = await models.comment.findAll({
    where: { parentId: comment.id },
    order: [['createdAt', 'ASC']]
  });
  // 递归给每个子评论添加它们的子评论
  await Promise.all(children.map(attachChildren));
  comment.dataValues.children = children;
  return comment;
}

router.get('/article/:id/comments', async (req, res, next) => {
  try {
    const articleId = req.params.id;
    // 获取所有根评论（parentId为null）
    const rootComments = await models.comment.findAll({
      where: { articleId, parentId: null },
      order: [['createdAt', 'ASC']]
    });

    // 给每个根评论递归挂载子评论
    const nestedComments = await Promise.all(rootComments.map(attachChildren));
    res.json(nestedComments);
  } catch (err) {
    next(err);
  }
});

优点：逻辑直观，容易理解；缺点：会产生N+1次数据库查询（N是评论层级数+根评论数），评论多的时候性能较差。

方案3：Sequelize递归Include配置 #

利用Sequelize的include选项递归嵌套查询，适合固定层级的评论场景（比如最多3层评论）：

// 生成递归的Include配置函数
function getRecursiveInclude(depth = 3) {
  if (depth <= 0) return [];
  return [{
    model: models.comment,
    as: 'children',
    include: getRecursiveInclude(depth - 1),
    order: [['createdAt', 'ASC']]
  }];
}

router.get('/article/:id/comments', async (req, res, next) => {
  try {
    const articleId = req.params.id;
    // 直接查询根评论并递归包含子评论
    const nestedComments = await models.comment.findAll({
      where: { articleId, parentId: null },
      include: getRecursiveInclude(3), // 指定最大递归深度，比如3层
      order: [['createdAt', 'ASC']]
    });
    res.json(nestedComments);
  } catch (err) {
    next(err);
  }
});

优点：代码简洁，用Sequelize原生关联实现；缺点：无法处理无限层级（必须指定深度），层级深时同样会产生多轮数据库查询，性能不如方案1。

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