コールバック、Promise、async/await を比較してください。

Question

IT Interview Practice · Accepted Answer

これらは Node における **非同期** 操作を扱う 3 世代の手法であり、それぞれが前世代よりも可読性を高めていますが、いずれも同じイベントループという基盤の上に成り立っています。

## 1. コールバック — 最初の手法（そして「コールバック地獄」）

```js
fs.readFile("a.txt", (err, a) => {
  if (err) return handle(err);            // error-first callback convention
  fs.readFile("b.txt", (err, b) => {       // nesting deepens with each step...
    if (err) return handle(err);
    db.save(a + b, (err) => {              // "pyramid of doom"
      if (err) return handle(err);
    });
  });
});
```

Node の慣習は **エラーファーストコールバック**（`(err, result)`）です。これらは機能しますが、深くネストし、エラー処理が散在するため、読みにくく保守しにくくなります。

## 2. Promise — 連鎖可能で、よりフラット

```js
readFile("a.txt")
  .then(a => readFile("b.txt").then(b => a + b)) // return a promise → chain waits
  .then(combined => db.save(combined))
  .catch(handle);                                 // ONE place for all errors
```

Promise は将来の値を表します。`.then` がステップを連鎖させ、`.catch` がチェーン内のあらゆるエラーを処理します。ネストしたコールバックよりフラットです。

## 3. async/await — 同期的に見える（現代の標準）

```js
async function combine() {
  try {
    const a = await readFile("a.txt");   // pause until resolved
    const b = await readFile("b.txt");
    await db.save(a + b);
  } catch (err) {
    handle(err);                          // normal try/catch works
  }
}
```

`async/await` は Promise の糖衣構文です。同期コードのように上から下へ読め、通常の `try/catch` を使え、現代で推奨されるスタイルです。

## 独立した処理を直列化しない

```js
// ❌ sequential — slow
const a = await getA(); const b = await getB();
// ✅ parallel — both at once
const [a, b] = await Promise.all([getA(), getB()]);
```

## 三者の関係

```text
Callbacks → Promises → async/await
All use the event loop. Promises wrap callbacks; async/await wraps Promises.
Modern code: async/await, with Promise.all to parallelize independent ops.
```

## なぜ重要なのか

非同期処理は Node では避けて通れません（すべての I/O が非同期です）。

この進化 — エラーファーストコールバック（古い API やライブラリで今も一般的）、Promise（連鎖可能）、async/await（読みやすく、標準）— を理解することで、どんなコードベースも読め、クリーンな非同期ロジックを書けます。

これらがすべて根底では同じイベントループの仕組みであることを知り、独立した操作を `Promise.all` で並列化することを忘れないことが、正しく高性能な非同期 Node コードの鍵です。

1. コールバック — 最初の手法（そして「コールバック地獄」）

2. Promise — 連鎖可能で、よりフラット

3. async/await — 同期的に見える（現代の標準）

独立した処理を直列化しない

三者の関係

なぜ重要なのか

関連する質問