Vergleichen Sie Callbacks, Promises und async/await.

Question

Accepted Answer

Dies sind drei Generationen der Behandlung **asynchroner** Operationen in Node — jede verbessert die Lesbarkeit gegenüber der vorherigen, aber alle sind auf dieselbe Event-Loop-Grundlage aufgebaut.

## 1. Callbacks — das Original (und die « Callback-Hölle »)

```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);
    });
  });
});
```

Nods Konvention ist **Error-First-Callbacks** (`(err, result)`). Sie funktionieren, verschachteln sich aber tief und verteilen die Fehlerbehandlung — schwer zu lesen und zu warten.

## 2. Promises — verkettbar, flacher

```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
```

Ein Promise stellt einen zukünftigen Wert dar; `.then` verkettet Schritte und `.catch` behandelt jeden Fehler in der Kette — flacher als verschachtelte Callbacks.

## 3. async/await — synchron aussehend (der moderne Standard)

```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` ist syntaktischer Zucker über Promises — es liest sich von oben nach unten wie synchroner Code, verwendet gewöhnliche `try/catch` und ist der empfohlene moderne Stil.

## Serialisieren Sie unabhängige Arbeiten nicht

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

## Die Beziehung

```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.
```

## Warum es wichtig ist

Asynchrone Behandlung ist in Node unvermeidlich (alle I/O-Operationen sind asynchron).

Das Verständnis der Entwicklung — Error-First-Callbacks (immer noch häufig in älteren APIs/Bibliotheken), Promises (verkettbar) und async/await (lesbar, der Standard) — ermöglicht es Ihnen, jeden Codebestand zu lesen und saubere asynchrone Logik zu schreiben.

Zu wissen, dass sie alle derselbe Event-Loop-Mechanismus zugrunde liegen, und sich daran zu erinnern, unabhängige Operationen mit `Promise.all` zu parallelisieren, ist der Schlüssel zu korrektem und performantem asynchronem Node-Code.