Node.js 编程实战：全面理解异步错误处理

在 Node.js 开发中，程序的大部分操作都是异步执行的，例如文件读写、网络请求、数据库操作等。异步带来了高性能的优势，但也让错误处理变得更加复杂。如果处理不当，错误可能悄无声息地被忽略，导致程序异常、资源泄漏，甚至服务崩溃。理解并正确掌握 Node.js 的异步错误处理机制，是构建稳定可靠服务的重要前提。

本文将系统讲解 Node.js 中的异步错误处理策略，包括回调、Promise、async/await，以及常见陷阱和最佳实践。

一、为什么异步错误处理更难？

在同步代码中，只需要 try/catch 即可捕获异常：

js 复制代码

try {
  const data = readFileSync("a.txt");
} catch (err) {
  console.error(err);
}

但在异步代码中，异常并不会被外围的 try/catch 捕获。例如：

js 复制代码

try {
  fs.readFile("a.txt", (err, data) => {
    if (err) throw err;
  });
} catch (err) {
  console.log("捕获不到错误");
}

原因在于：回调在未来某个时间点执行，已经脱离了 try/catch 的同步范围。

因此，Node.js 引入了不同阶段的错误处理模式。

二、回调风格中的"错误优先"规则

Node.js 所有基于回调的 API 都遵循一个约定：回调的第一个参数永远是错误对象。

例如：

js 复制代码

fs.readFile("demo.txt", "utf8", (err, data) => {
  if (err) {
    console.error("读取失败：", err);
    return;
  }
  console.log(data);
});

这是处理异步错误的基础方式。好处是：

明确区分成功和失败
调用者必须显式处理错误，避免吞错
提升代码安全性

但随着嵌套回调增多，错误处理也会变得重复甚至混乱。

三、Promise 中的错误捕获

Promise 的设计让错误处理更清晰，任何抛出的异常都会被 .catch() 捕获。

js 复制代码

new Promise((resolve, reject) => {
  reject(new Error("失败了"));
})
  .then(() => {})
  .catch(err => {
    console.error("捕获到错误：", err);
  });

Promise 的错误处理有几种特点：

只要 reject 或者 then 中抛出异常，都能被 catch 捕获
在链式调用中，只需一个 catch 即可捕获所有上游错误
未处理的 Promise 错误会触发 unhandledRejection 事件

例如：

js 复制代码

process.on("unhandledRejection", (err) => {
  console.error("未捕获的 Promise 错误：", err);
});

在生产环境中，这类错误必须记录，否则将难以排查。

四、async/await 的错误处理方式

async/await 是构建整洁异步代码的关键，但错误处理仍然要使用 try/catch。

示例：

js 复制代码

async function run() {
  try {
    const data = await readFileAsync("demo.txt");
    console.log(data);
  } catch (err) {
    console.error("捕获错误：", err);
  }
}

try/catch 在 async/await 中有几个优势：

可读性强，结构和同步逻辑一致
一段代码中可以统一处理多个 await 的错误
调试更方便

但常见错误是：把 try/catch 放错位置，导致部分 await 未被包含。

五、如何处理多个并发任务的错误？

当多个异步任务同时执行时，错误处理方式更为复杂。

1. Promise.all：其中一个失败就全部失败

js 复制代码

try {
  const results = await Promise.all([taskA(), taskB(), taskC()]);
} catch (err) {
  console.error("其中一个任务失败：", err);
}

适用于"任务必须同时成功"的场景。

2. Promise.allSettled：每个任务独立执行

js 复制代码

const results = await Promise.allSettled([taskA(), taskB(), taskC()]);

返回结果中：

fulfilled 代表成功
rejected 代表失败

非常适合批量处理或任务结果不互相依赖的场景。

六、常见的异步错误陷阱

1. 忘记返回 Promise

js 复制代码

function wrong() {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve();
    }, 1000);
  }).then(() => {
    throw new Error("错误");
  });
}

async function run() {
  try {
    wrong();
  } catch (err) {
    console.log("捕获不到");
  }
}

原因：没有 return，导致 run() 无法等待错误抛出。

2. 在 forEach 中使用 await

forEach 不能等待异步任务，因此错误难以捕获。

js 复制代码

items.forEach(async item => {
  await process(item); // 错误无法被外层捕获
});

正确方式：

js 复制代码

for (const item of items) {
  await process(item);
}

3. async 函数中的未处理错误最终会导致 Promise rejection

如果没有 try/catch，也没有被外层 await 捕获，错误会引发 unhandledRejection。

七、全局层面的异常处理

即使处理了大多数错误，仍可能出现未捕获错误。 Node.js 提供全局事件用于兜底：

1. 未捕获的异常

js 复制代码

process.on("uncaughtException", (err) => {
  console.error("未捕获异常：", err);
});

2. 未捕获的 Promise 错误

js 复制代码

process.on("unhandledRejection", (err) => {
  console.error("未处理的 Promise 错误：", err);
});

在生产环境，通常会记录日志并安全退出，而不是继续运行。

八、最佳实践总结

回调函数中始终检查 err
Promise 链中使用统一的 catch
async/await 中使用 try/catch 进行局部保护
批量任务优先选择 Promise.allSettled
避免在 forEach 中使用 await
必须监听 unhandledRejection 和 uncaughtException
对外暴露 API 时防止错误被吞掉

高质量的异步错误处理不仅提升稳定性，也能显著降低维护成本。

九、总结

Node.js 的异步错误处理机制看似复杂，但它遵循清晰规律：回调依赖错误优先模式，Promise 依赖 catch，async/await 依赖 try/catch。理解每种模式的特点和适用场景，就能写出可靠、可维护的 Node.js 服务。