嵌套异步循环重复触发响应，引发ERR_HTTP_HEADERS_SENT错误求助

你遇到的Error [ERR_HTTP_HEADERS_SENT]错误，本质是回调函数被多次调用，导致Express试图重复向客户端发送响应头。咱们来一步步拆解问题原因，再给出可行的修复方案。

错误根源 #

你的代码里用了count和inner_count两个计数器来判断异步操作是否完成，但逻辑存在漏洞：

• count在divisions.forEach的每次循环里都会递增，很快就会等于divisions.length（比如你的示例里是3）。
• 每个division的内层异步循环（比如处理teams）完成时，只要inner_count等于当前division的teams长度，同时count已经等于总division数，就会触发callback。
• 这就导致每个division的内层循环结束时，都会触发一次回调，最终多次调用callback，引发重复响应的错误。

修复方案 #

方案一：修正计数器逻辑（回调风格） #

我们可以先统计所有需要执行的异步任务总数，每完成一个任务就累加完成数，只有当所有任务都完成时才调用一次回调：

const getDivisionsByLeagueId = (callback) => {
  if (divisions.length === 0) {
    return callback('error', null);
  }

  // 先统计所有需要执行的异步任务总数
  let totalTasks = 0;
  divisions.forEach(division => {
    totalTasks += division.tournament ? division.players.length : division.teams.length;
  });

  let completedTasks = 0;

  divisions.forEach((division, dindex) => {
    if (division.tournament) {
      division.players.forEach((player, index) => {
        calcTournamentStats(player, division._id, (err, result) => {
          if (err) return callback(err, null); // 出错时立即返回，避免后续执行
          
          completedTasks++;
          divisions[dindex].players[index] = result;
          
          // 只有所有任务都完成时才触发回调
          if (completedTasks === totalTasks) {
            callback(null, divisions);
          }
        });
      });
    } else {
      division.teams.forEach((team, index) => {
        calcStats(team, division._id, (err, result) => {
          if (err) return callback(err, null);
          
          completedTasks++;
          divisions[dindex].teams[index] = result;
          
          if (completedTasks === totalTasks) {
            callback(null, divisions);
          }
        });
      });
    }
  });
};

方案二：改用Promise + async/await（推荐） #

回调嵌套容易出错，用Promise和async/await可以让异步代码更清晰，从根源上避免回调多次调用的问题：

首先把异步函数封装成Promise：

// 封装成Promise版本
const calcTournamentStats = (player, division_id) => {
  return new Promise(resolve => {
    setTimeout(() => resolve('Anthony'), 2000);
  });
};

const calcStats = (team, division_id) => {
  return new Promise(resolve => {
    setTimeout(() => resolve('Team F'), 2000);
  });
};

然后重构getDivisionsByLeagueId为async函数：

const getDivisionsByLeagueId = async () => {
  if (divisions.length === 0) {
    throw new Error('No divisions available');
  }

  // 遍历每个division，并行处理内部的异步任务
  for (const division of divisions) {
    if (division.tournament) {
      // 用Promise.all并行处理所有player的异步请求
      division.players = await Promise.all(
        division.players.map(player => calcTournamentStats(player, division._id))
      );
    } else {
      // 并行处理所有team的异步请求
      division.teams = await Promise.all(
        division.teams.map(team => calcStats(team, division._id))
      );
    }
  }

  return divisions;
};

调用方式也更简洁（以Express路由为例）：

app.get('/divisions', async (req, res) => {
  try {
    const result = await getDivisionsByLeagueId();
    res.json(result); // 只会发送一次响应
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

总结 #

• 回调风格的代码容易出现计数器逻辑错误，导致多次触发响应；
• Promise + async/await的方式更直观，代码可读性和可维护性更强，能有效避免这类问题。

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