Node.js 异步问题：回调地狱与 async/await

Node.js 以非阻塞 I/O 和事件驱动模型著称，这让它擅长处理高并发任务。但异步编程也带来了独特的挑战——最典型的就是“回调地狱”（Callback Hell）。本文手把手教你识别、避免回调地狱，并用 async/await 写出清晰可维护的代码。

什么是回调地狱？

当你需要依次执行多个异步操作（比如读取文件、查询数据库、发送 HTTP 请求），如果每个操作都依赖前一个的结果，传统写法会层层嵌套回调函数。代码缩进越来越深，逻辑难以追踪，错误处理也变得混乱。

例如，假设你要：

1. 读取用户配置文件；
2. 根据配置连接数据库；
3. 查询用户数据；
4. 将结果写入日志文件。

用纯回调写法会变成这样：

const fs = require('fs');

fs.readFile('config.json', 'utf8', (err, configData) => {
  if (err) {
    console.error('读取配置失败:', err);
    return;
  }
  const config = JSON.parse(configData);

  connectToDB(config.dbUrl, (err, db) => {
    if (err) {
      console.error('连接数据库失败:', err);
      return;
    }

    db.query('SELECT * FROM users', (err, users) => {
      if (err) {
        console.error('查询用户失败:', err);
        return;
      }

      fs.writeFile('log.txt', JSON.stringify(users), (err) => {
        if (err) {
          console.error('写入日志失败:', err);
          return;
        }
        console.log('全部完成');
      });
    });
  });
});

这种金字塔形的代码就是典型的回调地狱。嵌套层级越多，代码越难读、越难改、越难调试。

解决方案一：使用 Promise

Promise 是 JavaScript 内置的异步处理对象，能将回调扁平化。它的核心思想是：每个异步操作返回一个“承诺”，你可以通过 .then() 处理成功结果，通过 .catch() 统一捕获错误。

改造步骤如下：

1. 将回调式 API 包装成返回 Promise 的函数。Node.js 提供了 util.promisify 工具。
2. 用链式 .then() 替代嵌套回调。
3. 在链末尾用 .catch() 捕获任意环节的错误。

先包装文件和数据库操作：

const fs = require('fs');
const util = require('util');

// 将回调函数转为 Promise 函数
const readFile = util.promisify(fs.readFile);
const writeFile = util.promisify(fs.writeFile);

// 假设 connectToDB 和 db.query 也有 Promise 版本
function connectToDB(url) {
  // 返回一个 Promise
  return new Promise((resolve, reject) => {
    // 模拟连接逻辑
    setTimeout(() => {
      if (Math.random() > 0.1) {
        resolve({ query: (sql) => new Promise((res) => setTimeout(() => res([{ id: 1, name: 'Alice' }]), 100)) });
      } else {
        reject(new Error('DB 连接失败'));
      }
    }, 100);
  });
}

然后用 Promise 链式调用：

readFile('config.json', 'utf8')
  .then(configData => JSON.parse(configData))
  .then(config => connectToDB(config.dbUrl))
  .then(db => db.query('SELECT * FROM users'))
  .then(users => writeFile('log.txt', JSON.stringify(users)))
  .then(() => console.log('全部完成'))
  .catch(err => console.error('发生错误:', err));

现在代码从垂直嵌套变成了水平链式，逻辑线性、错误统一处理，可读性大幅提升。

解决方案二：使用 async/await（推荐）

async/await 是基于 Promise 的语法糖，让异步代码看起来像同步代码。它更直观、更符合人类思维习惯。

使用规则：

• 在函数声明前加 async，该函数自动返回 Promise。
• 在异步操作前加 await，JavaScript 会暂停执行，等待 Promise 完成后再继续。
• 用 try...catch 捕获错误，就像处理同步异常一样。

重写上述流程：

const fs = require('fs');
const util = require('util');

const readFile = util.promisify(fs.readFile);
const writeFile = util.promisify(fs.writeFile);

// 假设 connectToDB 已返回 Promise
async function processUserData() {
  try {
    const configData = await readFile('config.json', 'utf8');
    const config = JSON.parse(configData);

    const db = await connectToDB(config.dbUrl);
    const users = await db.query('SELECT * FROM users');

    await writeFile('log.txt', JSON.stringify(users));
    console.log('全部完成');
  } catch (err) {
    console.error('发生错误:', err);
  }
}

processUserData();

这段代码几乎和同步代码一样清晰。每个 await 表示“等这个操作做完再往下走”，无需链式调用，也无需手动传递中间值。

对比三种写法的关键差异

下面表格总结了回调、Promise、async/await 在错误处理、代码结构和可读性上的区别：

实战建议：如何迁移旧代码？

如果你正在维护一个充满回调的老项目，按以下步骤逐步升级：

1. 识别高频异步操作：如文件读写、数据库查询、HTTP 请求。
2. 用 util.promisify 包装这些操作（Node.js 8+ 内置）：

   const { promisify } = require('util');
   const exec = promisify(require('child_process').exec);

3. 新建函数时优先使用 async/await，不要新增回调嵌套。
4. 重构关键路径：挑选最复杂的回调地狱模块，一次性重写为 async/await。
5. 统一错误处理策略：在顶层 async 函数外用 .catch() 或 Express/Koa 的错误中间件兜底。

注意：await 只能在 async 函数内部使用。顶层代码（如脚本入口）若需等待，可包裹在立即执行的 async 函数中：

(async () => {
  await someAsyncTask();
})();

避免 async/await 的常见误区

虽然 async/await 强大，但也有陷阱：

• 不要在循环里直接 await（除非必须串行执行）：

  // ❌ 低效：逐个等待，总耗时 = 各任务时间之和
  for (const url of urls) {
    const data = await fetch(url);
    results.push(data);
  }
  
  // ✅ 高效：并行发起请求
  const promises = urls.map(url => fetch(url));
  const results = await Promise.all(promises);

• 记得处理被忽略的 Promise：如果不用 await 也不用 .catch()，错误会被静默吞掉。

• 避免 async 函数无意义包装：如果函数内部没有 await，没必要加 async。

使用 async/await 编写异步代码，是现代 Node.js 开发的标准实践。它消除了回调地狱，让复杂流程变得简单可控。从今天开始，把你的嵌套回调一层层解开，换成清晰的 await 调用吧。