Node.js 异步编程：Promise 与 Async/Await 详解

引言 / 什么是异步编程

Node.js 作为基于事件驱动的非阻塞 I/O 模型的后端开发框架，异步编程是其核心特性。与同步编程的线性执行不同，异步编程通过回调函数、Promise 或 Async/Await 实现非阻塞操作，特别适合处理高并发的 I/O 密集型任务（如文件读写、网络请求）。

传统回调函数（Callback）虽然简单，但容易陷入“回调地狱”（Callback Hell），导致代码难以维护。Promise 和 Async/Await 的出现解决了这一问题，它们提供了更优雅的异步代码组织方式，同时保持了代码的可读性和可维护性。

本文将系统讲解 Promise 和 Async/Await 的用法，并通过文件读取和网络请求的实际案例对比不同异步处理方式，帮助你掌握 Node.js 异步编程的核心技巧。

准备工作

• Node.js 版本：建议使用 LTS 版本（如 18.x 或更高）
• 编辑器：VS Code 或其他支持 JavaScript 的编辑器
• 示例代码依赖：fs/promises（Node.js 内置模块）、axios（HTTP 客户端库）

Promise 基础与高级用法

步骤一：Promise 的基本结构

Promise 是一个对象，表示异步操作的最终完成（或失败）及其结果值。它有三种状态：

• Pending（进行中）：初始状态，既未完成也未失败。
• Fulfilled（已成功）：操作成功完成。
• Rejected（已失败）：操作失败。

const promise = new Promise((resolve, reject) => {
  // 模拟异步操作（如文件读取）
  setTimeout(() => {
    const success = true; // 模拟操作结果
    if (success) {
      resolve("操作成功！"); // 成功时调用 resolve
    } else {
      reject(new Error("操作失败！")); // 失败时调用 reject
    }
  }, 1000);
});

promise
  .then((result) => {
    console.log(result); // 输出：操作成功！
  })
  .catch((error) => {
    console.error(error.message); // 捕获错误
  });

步骤二：Promise 的链式调用

Promise 的核心优势是链式调用，通过 .then() 方法将多个异步操作串联起来，避免嵌套回调。

function fetchData(url) {
  return new Promise((resolve) => {
    setTimeout(() => resolve(`数据来自 ${url}`), 500);
  });
}

fetchData("https://api.example.com/users")
  .then((data) => {
    console.log(data); // 输出：数据来自 https://api.example.com/users
    return fetchData("https://api.example.com/posts"); // 返回新的 Promise
  })
  .then((data) => {
    console.log(data); // 输出：数据来自 https://api.example.com/posts
  });

步骤三：Promise 的静态方法

Promise 提供了多个静态方法简化异步操作：

• Promise.all()：等待所有 Promise 完成（并行操作）。
• Promise.race()：返回第一个完成或拒绝的 Promise。
• Promise.allSettled()：等待所有 Promise 完成（无论成功或失败）。

const promise1 = Promise.resolve("结果1");
const promise2 = new Promise((resolve) => setTimeout(() => resolve("结果2"), 1000));

// Promise.all 示例
Promise.all([promise1, promise2])
  .then((results) => {
    console.log(results); // 输出：["结果1", "结果2"]
  });

// Promise.race 示例
Promise.race([promise1, promise2])
  .then((result) => {
    console.log(result); // 输出：结果1（先完成的）
  });

Async/Await 语法与优势

步骤一：Async/Await 的基本用法

Async/Await 是基于 Promise 的语法糖，用同步方式编写异步代码，提升可读性。

• async 函数：声明一个异步函数，返回一个 Promise。
• await 表达式：暂停异步函数的执行，等待 Promise 完成。

async function fetchUser() {
  try {
    const response = await fetch("https://api.example.com/users");
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error("请求失败：", error);
  }
}

fetchUser();

提示：await 只能在 async 函数内部使用，否则会报语法错误。

步骤二：错误处理

Async/Await 通过 try/catch 捕获错误，比 Promise 的 .catch() 更直观。

async function readFile(path) {
  try {
    const fs = require("fs/promises");
    const content = await fs.readFile(path, "utf-8");
    console.log(content);
  } catch (error) {
    console.error("文件读取失败：", error.message);
  }
}

readFile("./nonexistent.txt"); // 输出：文件读取失败：ENOENT: no such file or directory

步骤三：并行优化

虽然 await 会暂停执行，但可以通过并行调用优化性能。

async function fetchDataInParallel() {
  const [users, posts] = await Promise.all([
    fetch("https://api.example.com/users").then((res) => res.json()),
    fetch("https://api.example.com/posts").then((res) => res.json()),
  ]);
  console.log(users, posts);
}

fetchDataInParallel();

实际案例对比：文件读取与网络请求

案例一：文件读取

回调函数方式：

const fs = require("fs");

fs.readFile("./example.txt", "utf-8", (err, data) => {
  if (err) {
    console.error(err);
    return;
  }
  console.log(data);
});

Promise 方式：

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

fs.readFile("./example.txt", "utf-8")
  .then((data) => console.log(data))
  .catch((err) => console.error(err));

Async/Await 方式：

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

async function readFile() {
  try {
    const data = await fs.readFile("./example.txt", "utf-8");
    console.log(data);
  } catch (err) {
    console.error(err);
  }
}

readFile();

案例二：网络请求

回调函数方式（以 request 库为例）：

const request = require("request");

request("https://api.example.com/users", (err, response, body) => {
  if (err) {
    console.error(err);
    return;
  }
  console.log(JSON.parse(body));
});

Promise 方式（以 axios 为例）：

const axios = require("axios");

axios.get("https://api.example.com/users")
  .then((response) => console.log(response.data))
  .catch((err) => console.error(err));

Async/Await 方式：

const axios = require("axios");

async function fetchUsers() {
  try {
    const response = await axios.get("https://api.example.com/users");
    console.log(response.data);
  } catch (err) {
    console.error(err);
  }
}

fetchUsers();

常见问题

Q：Async/Await 会阻塞主线程吗？
A：不会。await 仅暂停当前 async 函数的执行，不会阻塞 Node.js 事件循环。其他异步操作仍可并行执行。

Q：如何处理多个并行异步操作？
A：使用 Promise.all() 或 Promise.allSettled() 结合 map 方法。例如：

async function fetchMultipleUrls(urls) {
  const promises = urls.map((url) => axios.get(url));
  const responses = await Promise.all(promises);
  console.log(responses.map((res) => res.data));
}

Q：Promise 和 Async/Await 如何选择？
A：

• 简单场景：直接使用 Promise 的链式调用。
• 复杂逻辑：优先使用 Async/Await，代码更清晰。
• 需要并行优化：结合 Promise.all() 和 await。

小结

本文系统讲解了 Node.js 异步编程的两种核心方式：Promise 和 Async/Await。Promise 通过链式调用和静态方法解决了回调地狱问题，而 Async/Await 进一步用同步语法简化了异步代码的编写。通过文件读取和网络请求的实际案例对比，可以直观感受到两者的优势。

建议在实际开发中：

1. 优先使用 fs/promises 和 axios 等支持 Promise 的库。
2. 复杂逻辑用 Async/Await 提升可读性。
3. 并行操作使用 Promise.all() 优化性能。

掌握这些技巧后，你的 Node.js 代码将更高效、易维护，项目性能也会显著提升！