Node.js异步编程入门：回调函数与Promise基础

在学习Node.js时，我们经常会遇到“异步编程”这个概念。这是因为Node.js基于JavaScript语言，而JavaScript是单线程的，这种特性使得异步编程成为处理高并发I/O操作（比如文件读取、网络请求）的关键。如果不理解异步编程，可能会写出阻塞程序、性能低下的代码。

为什么需要异步编程？¶

想象一下，如果我们有一个Node.js程序，需要先读取一个大文件，然后处理文件内容，最后打印结果。如果用“同步”方式处理，代码会这样执行：

// 同步读取文件（简单示例，实际大文件会很慢）
const fs = require('fs');
const content = fs.readFileSync('bigfile.txt', 'utf8'); // 同步阻塞，等待文件读取完成
console.log('文件内容处理结果：', processContent(content));

这里的readFileSync是“同步读取”，执行时会阻塞整个程序，直到文件完全读取完毕。如果文件很大（比如几GB），用户会看到程序“卡住”，这在实际应用中显然不可接受。

而“异步”编程的好处是：当程序执行耗时操作（如等待I/O）时，不会阻塞主线程，而是先处理其他任务，等异步操作完成后再通过回调或Promise通知结果。这就是Node.js高效处理大量并发请求的核心。

回调函数：异步编程的基石¶

最早，Node.js使用“回调函数”（Callback）处理异步操作。回调函数就是一个“完成后调用的函数”，当异步操作完成时，Node.js会自动调用这个函数。

回调函数的基本形式¶

以读取文件为例：

const fs = require('fs');

// 异步读取文件
fs.readFile('example.txt', 'utf8', (err, data) => {
  // 异步操作完成后，Node.js会调用这个回调函数
  if (err) { // 错误处理：如果读取失败，err会有内容
    console.error('读取失败：', err);
    return; // 发生错误时，终止当前回调逻辑
  }
  console.log('文件内容：', data); // 读取成功，打印内容
});

console.log('我会先执行！'); // 这行会立即输出，不会被阻塞

关键细节：
- fs.readFile的最后一个参数是回调函数，接收两个参数：err（错误对象，成功时为null）和data（异步操作结果）。
- 异步操作执行时，Node.js会先处理后续的同步代码（比如上面的console.log('我会先执行！')），不会等待异步操作完成。

回调函数的优缺点¶

优点：¶

简单直观：直接将“操作完成后的处理逻辑”作为参数传入，容易理解。
无需额外库：Node.js内置的API（如fs、setTimeout）都支持回调函数，上手快。

缺点：¶

回调地狱（Callback Hell）：当多个异步操作需要嵌套执行时（比如“先读取文件A，再用A的内容读取文件B，再用B的内容读取文件C”），代码会像“金字塔”一样嵌套，可读性极差。

示例：嵌套回调的“回调地狱”

// 先读取文件A，再读取文件B，再读取文件C（嵌套写法）
fs.readFile('A.txt', 'utf8', (err, dataA) => {
  if (err) throw err;
  fs.readFile('B.txt', 'utf8', (err, dataB) => {
    if (err) throw err;
    fs.readFile('C.txt', 'utf8', (err, dataC) => {
      if (err) throw err;
      console.log('最终内容：', dataA + dataB + dataC);
    });
  });
});

这种“层层嵌套”的代码不仅难以阅读，还会导致错误处理繁琐（每个回调都要重复写if (err)）。

Promise：让异步代码更线性¶

为了解决“回调地狱”，ES6引入了Promise对象，它是一个“承诺”——承诺异步操作最终会返回结果（成功或失败）。Promise让异步代码的执行顺序更接近“同步代码”，可读性大幅提升。

Promise的核心概念¶

状态：Promise有三种状态，一旦确定不可改变：
pending（进行中）：初始状态，异步操作正在执行。
fulfilled（成功）：异步操作完成，返回结果。
rejected（失败）：异步操作出错，返回错误信息。
构造与使用：通过new Promise创建实例，传入一个“执行器函数”，该函数包含两个参数：
resolve：异步操作成功时调用，传入结果。
reject：异步操作失败时调用，传入错误。
链式调用：Promise的.then()方法可以接收成功回调，返回一个新的Promise，支持连续调用（解决嵌套问题）。.catch()方法统一处理错误。

Promise的基本用法¶

示例1：用Promise封装异步读取文件¶

const fs = require('fs');

// 将fs.readFile包装成Promise形式（Node.js 10+支持fs.promises）
const readFilePromise = (path) => {
  return new Promise((resolve, reject) => {
    fs.readFile(path, 'utf8', (err, data) => {
      if (err) reject(err); // 失败时调用reject
      else resolve(data); // 成功时调用resolve，传入结果
    });
  });
};

// 使用Promise读取文件
readFilePromise('example.txt')
  .then((data) => {
    console.log('文件内容：', data); // 第一个异步操作成功后的结果
    return readFilePromise('another.txt'); // 链式调用，返回新Promise
  })
  .then((data2) => {
    console.log('第二个文件内容：', data2); // 第二个异步操作成功后的结果
  })
  .catch((err) => {
    console.error('出错了：', err); // 统一捕获所有错误
  });

示例2：模拟网络请求（用setTimeout模拟异步）¶

// 模拟一个异步任务（比如网络请求）
const simulateRequest = (success) => {
  return new Promise((resolve, reject) => {
    setTimeout(() => { // 模拟网络延迟（等待1秒）
      if (success) {
        resolve('请求成功，返回数据'); // 成功时调用resolve
      } else {
        reject(new Error('请求失败，网络错误')); // 失败时调用reject
      }
    }, 1000);
  });
};

// 使用Promise链式调用
simulateRequest(true) // 第一次请求成功
  .then((result) => {
    console.log(result); // 输出：请求成功，返回数据
    return simulateRequest(false); // 第二次请求故意失败
  })
  .then((result) => {
    console.log('不会执行到这里（因为上一步失败了）');
  })
  .catch((err) => {
    console.error('捕获到错误：', err.message); // 输出：捕获到错误：请求失败，网络错误
  });

关键改进：通过.then()链式调用，异步代码不再嵌套，而是像“流水线”一样依次执行，每个步骤的结果可以直接传给下一步，错误统一用.catch()处理。

总结：回调函数 vs Promise¶

对比项	回调函数	Promise
可读性	嵌套深时难以阅读（回调地狱）	链式调用，线性流程，易读性高
错误处理	每个回调都要重复写`if (err)`	统一用`.catch()`处理所有错误
扩展性	多异步操作需大量嵌套	支持链式调用，可串联多个异步操作

Promise的核心价值：让异步代码的执行顺序更接近“同步逻辑”，避免了回调嵌套的混乱，为后续学习async/await（Promise的语法糖）打下基础。

下一步学习方向¶

Promise虽然解决了回调地狱，但语法上仍有“then链”的嵌套感。ES2017引入的async/await进一步简化了异步代码，让我们可以用“同步写法”写异步逻辑。如果你想深入学习，可以继续了解async/await如何基于Promise实现更优雅的异步编程。

希望这篇文章能帮你入门Node.js的异步编程，记住：回调函数是基础，Promise是进阶，而理解异步思维是编写高效Node.js程序的关键！