Promise 异步链式调用与错误处理

在 Callback 时代，多层嵌套的回调让代码演变成难以维护的“金字塔”。ES6 引入的 Promise 从本质上改变了异步程序的写作方式，它把“未来某个时刻才会完成的操作”封装成一个对象，然后通过链式调用串联多个步骤，同时提供了一套统一的错误捕获机制。掌握 Promise 的链式调用与错误处理，是编写可维护 Node.js 代码的基本功。

Promise 的本质：一个代表未来值的容器

Promise 是一个状态机，初始为 pending，一旦操作完成就不可逆地转为 fulfilled 或 rejected。无论状态如何，对同一个 Promise 对象多次附加回调，都会得到相同的结果。这种一次确定、多次可读的特性，让异步操作的返回值变成了一个可以传递的对象，而不需要嵌套回调。

创建一个 Promise 是直白的：

function readFilePromise(path) {
  return new Promise((resolve, reject) => {
    fs.readFile(path, 'utf8', (err, data) => {
      if (err) reject(err);
      else resolve(data);
    });
  });
}

resolve 和 reject 分别将 Promise 推向成功或失败。重要的是，Promise 构造器内的回调是同步执行的，所以通常用于包装已有的回调风格 API。Node.js 内置的 util.promisify 可以自动完成这种包装，不必手写。

链式调用：`.then()` 的返回规则

Promise 的核心功能是 .then()。它接收两个可选参数：成功回调、失败回调，并返回一个新的 Promise。开发者通过链式调用可以将多个异步步骤按顺序串联起来。这种“扁平”的写法不会造成回调嵌套，代码的可读性明显提升。

readFilePromise('/etc/hosts')
  .then(data => {
    console.log('文件内容:', data);
    // 返回一个普通值
    return data.toUpperCase();
  })
  .then(upperData => {
    console.log('大写内容:', upperData);
    // 返回一个新的 Promise，链将等待它完成
    return anotherAsyncOperation(upperData);
  })
  .then(result => {
    console.log('后续结果:', result);
  });

链式调用的关键是 .then() 的返回值规则：

如果回调返回一个普通值，则 .then() 返回的新 Promise 立即解决为这个值。
如果回调返回一个 Promise，则外部 Promise 会“跟随”它：等待内部 Promise 完成，并采用相同的状态和结果；这一步让异步串联变得自然。
如果回调抛出一个异常，则返回的 Promise 会立即置为 rejected，异常对象会传递给下游的错误处理。

这种自动展开 Promise 的机制，使得我们可以像写同步代码一样描述一连串的异步操作。每一步既可以是同步的，也可以是异步的，链式调用自动处理等待关系。

错误处理：穿透式捕获与统一处理

Promise 的错误处理是它取代 Callback 的关键优势之一。在回调模式中，错误必须在每一个回调中单独检查，稍有不慎就会被忽略。Promise 将错误沿着链向下传播，直到被第一个 .catch() 处理。

readFilePromise('/nonexistent')
  .then(data => {
    // 这一步不会执行，因为 readFilePromise 已 reject
  })
  .then(() => {
    // 同样跳过
  })
  .catch(err => {
    console.error('文件读取失败:', err.message);
  });

这种机制允许我们把错误处理代码集中在链的末尾，避免在每个 .then() 中都写重复的逻辑。多个可能的失败点（网络请求、文件 I/O、数据解析）可以被同一个 catch 捕获，前提是错误在链中未被中途处理。

特别注意，.then(onFulfilled, onRejected) 的第二个参数也能捕获错误，但它只处理同一步产生的拒绝，不会传递给下一个 .catch()。实践中更推荐统一使用 .catch() 以避免遗漏，并使意图更清晰。

链中捕获与重试

虽然集中错误处理很方便，有时我们希望在链中恢复或重试。此时可以在 .catch() 里返回一个值或新的 Promise，链会从此处恢复正常执行。

fetchConfig()
  .then(parse)
  .catch(err => {
    console.warn('首次读取失败，尝试默认配置:', err.message);
    return defaultConfig;   // 返回一个普通值，链继续
  })
  .then(config => {
    // 无论使用解析结果还是默认配置，都会到达这里
    startServer(config);
  });

对于那些可以重试的操作，也可以把 .catch() 放在循环函数中。例如：

function retryOperation(operation, maxAttempts = 3) {
  return operation().catch(err => {
    if (maxAttempts <= 1) throw err;
    return retryOperation(operation, maxAttempts - 1);
  });
}

这种模式将异步重试封装成了链式调用的一部分。

Promise 链与微任务

Promise 的回调（.then, .catch, .finally）属于微任务。在 Node.js 的事件循环中，微任务在每个宏任务阶段完成之后立刻清空。这意味着 Promise 回调的延迟极小，但如果在同一个宏任务中连续追加大量微任务，也会延迟其他宏任务的执行。不过在实际业务中，这种延迟通常可以忽略，除非出现无限链。

实践中常犯的错误与最佳实践

忘记返回：在 .then() 内部如果启动了一个新 Promise，但没有用 return 将它与外部链连接，后续的 .then() 会立即执行，得到的是 undefined 而非真正的异步结果。始终确保用 return 将链延续下去：

  // 错误
  fetchUser().then(user => {
    saveUser(user); // 没有 return，后续 then 不会等待
  }).then(() => {
    // saveUser 可能还未完成
  });

  // 正确
  fetchUser().then(user => {
    return saveUser(user);
  }).then(() => {
    // 保证 saveUser 已经完成
  });

混合使用回调和 Promise：项目应统一风格，避免一部分函数用 Callback，另一部分用 Promise。对于遗留的回调 API，第一时间使用 util.promisify 或手动包装成 Promise。

吞掉错误：永远不要让链末端没有错误处理。一个未捕获的 Promise rejection 在 Node.js 中会触发 unhandledRejection 事件，并可能导致进程退出（取决于 Node 版本和标志）。在每一个独立 Promise 链的最后追加 .catch()，或是使用全局兜底机制。

反模式：用 Promise 构造函数包装已 Promise 的操作：如果已有返回 Promise 的函数，不要在外面再套一层 new Promise，可以直接返回它。

并发控制：链式调用解决的是顺序执行。如果需要同时发起多个异步操作，应该用 Promise.all 而非链条串行等待，除非业务必须顺序。

从回调到 Promise 的迁移价值

Promise 不仅让异步写法更接近同步思维，它还是 async/await 语法的底层基础。理解链式调用的展开机制和错误传播规则，就掌握了 async/await 所隐藏的细节。当代码中出现 await 时，它本质上就是 .then() 的语法糖；而 try...catch 能够捕获 await 表达式 reject，正是因为 Promise 链的错误可以被 .catch() 捕获。

正因为如此，哪怕现代代码中 async/await 更加常见，清晰理解 Promise 链的机制依然是 Node.js 开发者的必修课。很多生产环境的棘手 Bug —— 比如竞态忘记 return、错误未被正确处理 —— 根源往往在于对 Promise 行为理解不够透彻。掌握这些知识后，编写稳健的异步程序会变得自然而然。