如何在Promise链外部捕获未处理的Promise拒绝？

Got it，咱们先对齐下你的场景：你熟悉Promise机制和未处理拒绝的概念，但在给一串顺序执行的Promise函数做限流重试处理器时，卡在了精准捕获特定未处理Promise拒绝这一步——你用了基于Transform Stream的Limiter类做速率控制，但不知道怎么区分哪些拒绝是需要重试的，哪些是真正要抛出的未处理错误。

下面我给你拆解具体的实现思路和代码方案：

1. 先给Limiter类补全「限流+重试+错误标记」核心逻辑 #

Transform Stream的_transform方法是处理每个任务的核心，咱们可以在这里嵌入重试逻辑，同时给错误打标记，区分「可重试错误」和「不可重试错误」，这样就能精准定位要捕获的特定拒绝：

class Limiter extends TransformStream {
  constructor({ rateLimit = 1000, maxRetries = 3 }) {
    super({
      async transform(task, controller) {
        let retryCount = 0;
        let lastError;

        while (retryCount < maxRetries) {
          try {
            // 执行传入的Promise任务
            const result = await task();
            controller.enqueue(result);
            // 成功就跳出循环，处理下一个任务
            return;
          } catch (err) {
            lastError = err;
            // 关键：根据错误标记判断是否重试
            if (!err.isRetryable) {
              // 不可重试的错误，直接抛出（这就是你要捕获的特定未处理拒绝）
              throw err;
            }
            // 限流等待：按设定速率等待后重试
            await new Promise(resolve => setTimeout(resolve, rateLimit));
            retryCount++;
          }
        }

        // 重试次数耗尽，抛出带标记的最终错误
        const finalError = new Error(`任务重试${maxRetries}次后失败`);
        finalError.cause = lastError;
        finalError.isRetryExhausted = true;
        throw finalError;
      }
    });
  }
}

2. 精准捕获特定未处理Promise拒绝的两种方式 #

现在流处理中抛出的错误会沿着Promise链传递，你可以在消费流的时候针对性捕获：

方式1：在流的catch块中区分错误类型 #

当你把任务送入Limiter流后，通过catch块判断错误标记，处理特定的未处理拒绝：

// 示例：批量处理任务的函数
async function processTasks(tasks) {
  const limiter = new Limiter({ rateLimit: 1000, maxRetries: 3 });
  const writer = limiter.writable.getWriter();

  try {
    // 把任务逐个写入流
    for (const task of tasks) {
      await writer.write(() => task);
    }
    await writer.close();

    // 消费流的执行结果
    const reader = limiter.readable.getReader();
    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
      console.log("任务完成结果:", value);
    }
  } catch (err) {
    // 精准捕获特定未处理拒绝
    if (err.isRetryable === false) {
      console.error("捕获到不可重试的未处理拒绝:", err);
      // 这里可以做业务特定处理：比如告警、写入错误日志等
    } else if (err.isRetryExhausted) {
      console.error("任务重试耗尽的未处理拒绝:", err.cause);
      // 处理重试次数用完的情况
    } else {
      // 其他未预期错误，继续抛出（避免误吞）
      throw err;
    }
  }
}

方式2：给任务本身添加错误标记 #

如果你的任务Promise抛出的错误自带标识，Limiter可以直接识别：

// 示例：创建带错误标记的任务
function createTask(isRetryable) {
  return () => new Promise((resolve, reject) => {
    setTimeout(() => {
      const err = new Error("任务执行失败");
      err.isRetryable = isRetryable;
      reject(err);
    }, 100);
  });
}

// 使用示例
const tasks = [
  createTask(true), // 可重试错误
  createTask(false), // 不可重试错误（会触发特定未处理拒绝）
];
processTasks(tasks);

3. 全局兜底：避免漏网的未处理拒绝 #

如果担心局部捕获有遗漏，可以监听全局的unhandledrejection事件做兜底，但建议优先局部捕获：

process.on('unhandledrejection', (reason, promise) => {
  // 针对特定标记的错误做兜底处理
  if (reason.isRetryExhausted) {
    console.error("全局捕获到重试耗尽的未处理拒绝:", reason.cause);
  } else if (reason.isRetryable === false) {
    console.error("全局捕获到不可重试的未处理拒绝:", reason);
  } else {
    console.error("全局未处理Promise拒绝:", reason);
  }
});

这样一来，你既能通过Limiter实现限流重试，又能精准捕获那些你关心的特定未处理Promise拒绝，不会误吞或遗漏。

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