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程序的關鍵！