Node.js 异步编程核心

学习目标

本章是掌握 Node.js 的关键。你将学习如何处理异步操作，理解回调地狱的成因，并学会使用 Promise 和 async/await 编写出更清晰、更易于维护的异步代码。

Node.js 的核心优势之一是其非阻塞、事件驱动的架构，这使得它在处理 I/O 密集型任务时非常高效。而这一切都建立在异步编程的基础之上。

1. 回调函数 (Callbacks)

回调函数是 Node.js 中最基础的异步处理方式。它是一个在异步操作完成后被调用的函数。我们之前在 fs.readFile 中已经见过了。

const fs = require('fs');

console.log('开始...');

// readFile 是一个异步操作
fs.readFile('./file.txt', 'utf8', (error, data) => {
  // 这个函数就是回调函数
  if (error) {
    return console.error('出错了:', error);
  }
  console.log('文件内容:', data);
});

console.log('...结束');
// 输出顺序: 开始 -> ...结束 -> 文件内容: ...

回调地狱 (Callback Hell)

当多个异步操作相互依赖时，回调函数会层层嵌套，形成所谓的“回调地狱”或“末日金字塔”。这使得代码难以阅读和维护。

// 这是一个回调地狱的例子
fs.readFile('file1.txt', 'utf8', (err1, data1) => {
  if (err1) return console.error(err1);
  console.log(data1);
  fs.readFile('file2.txt', 'utf8', (err2, data2) => {
    if (err2) return console.error(err2);
    console.log(data2);
    fs.readFile('file3.txt', 'utf8', (err3, data3) => {
      if (err3) return console.error(err3);
      console.log(data3);
      // 如果还有更多操作...
    });
  });
});

为了解决这个问题，社区发展出了更先进的异步处理模式。

2. Promise

Promise 是 ES6 (ECMAScript 2015) 引入的，它是一个代表了异步操作最终完成或失败的对象。一个 Promise 可能处于以下三种状态之一：

• Pending (进行中)：初始状态，既不是成功，也不是失败。
• Fulfilled (已成功)：意味着操作成功完成。
• Rejected (已失败)：意味着操作失败。

使用 Promise

许多现代的 Node.js 库（包括 Node.js 核心模块的 fs/promises 版本）都原生支持 Promise。

const fs = require('fs/promises');

fs.readFile('file.txt', 'utf8')
  .then(data => {
    // 操作成功时执行
    console.log('Promise 成功:', data);
  })
  .catch(error => {
    // 操作失败时执行
    console.error('Promise 失败:', error);
  });

使用 Promise，我们可以将“回调地狱”的例子改写成更扁平、更易读的链式调用：

fs.readFile('file1.txt', 'utf8')
  .then(data1 => {
    console.log(data1);
    return fs.readFile('file2.txt', 'utf8');
  })
  .then(data2 => {
    console.log(data2);
    return fs.readFile('file3.txt', 'utf8');
  })
  .then(data3 => {
    console.log(data3);
  })
  .catch(error => {
    // 任何一步出错都会被这里捕获
    console.error('链式调用中发生错误:', error);
  });

3. async/await

async/await 是在 ES2017 中引入的，它被誉为“异步编程的终极解决方案”。它只是 Promise 的“语法糖”，让我们能用一种更像同步代码的方式来编写异步逻辑。

• async：用于声明一个函数是异步的。异步函数会自动返回一个 Promise。
• await：只能在 async 函数内部使用。它会暂停函数的执行，等待一个 Promise 完成，然后返回 Promise 的结果。

使用 async/await

现在，让我们用 async/await 来重写之前的链式读取文件的例子。代码看起来就像是同步执行的，非常直观！

const fs = require('fs/promises');

async function readAllFiles() {
  try {
    const data1 = await fs.readFile('file1.txt', 'utf8');
    console.log(data1);

    const data2 = await fs.readFile('file2.txt', 'utf8');
    console.log(data2);

    const data3 = await fs.readFile('file3.txt', 'utf8');
    console.log(data3);

  } catch (error) {
    console.error('使用 async/await 读取文件时出错:', error);
  }
}

readAllFiles();

try...catch 语句可以优雅地捕获 await 表达式中任何一个 Promise 的拒绝（rejection）。

总结

在本章中，我们深入探讨了 Node.js 异步编程的演进：

1. ✅ 回调函数：理解了其基本用法和“回调地狱”的弊端。
2. ✅ Promise：学会了使用 .then() 和 .catch() 来处理异步操作，实现了链式调用。
3. ✅ async/await：掌握了使用同步风格编写异步代码的现代方法，大大提高了代码的可读性。

最佳实践

在现代 Node.js 开发中，强烈推荐使用 async/await 来处理所有异步操作。它让代码更简洁、逻辑更清晰。

下一步

我们已经掌握了 Node.js 的核心概念。在下一章，我们将讨论一些更实际的话题，如如何处理 JSON 数据以及在 Web 开发中需要注意的基础安全问题。