Welche Utilities helfen bei der Arbeit mit asynchronem Code (promisify, AbortController)?

Question

Accepted Answer

Node bietet mehrere Utilities, die asynchronen Code sauberer und steuerbarer machen — durch die Konvertierung alter Callback-APIs in Promises, das Abbrechen von Operationen und die Koordination mehrerer asynchroner Aufgaben.

## promisify — Callback-APIs in Promises umwandeln

```js
import { promisify } from "util";
import fs from "fs";

// turn an error-first callback function into a Promise-returning one
const readFileAsync = promisify(fs.readFile);
const data = await readFileAsync("file.txt", "utf8"); // now awaitable
```

`promisify` wickelt jede Standard-`(args..., (err, result) => {})` Callback-Funktion ein, sodass du sie mit `await` verwenden kannst — nützlich für ältere Bibliotheken, die Promises nicht unterstützen. (Viele eingebaute APIs bieten inzwischen direkt Promise-Versionen an, z. B. `fs/promises`.)

## AbortController — asynchrone Operationen abbrechen

```js
const controller = new AbortController();

// pass the signal to a cancellable operation
const promise = fetch("https://api.example.com", { signal: controller.signal });

// cancel it (e.g. on timeout or user navigation)
setTimeout(() => controller.abort(), 5000); // abort after 5s

try {
  await promise;
} catch (err) {
  if (err.name === "AbortError") console.log("request cancelled");
}
```

`AbortController` bietet eine Standard-Möglichkeit, um laufende Operationen **abzubrechen** (fetch, Timer, Streams, viele Bibliotheken) — essentiell für Timeouts und um verschwendete Arbeit zu vermeiden, wenn ein Ergebnis nicht mehr benötigt wird.

## Promise-Kombinatoren — koordiniere mehrere asynchrone Aufgaben

```js
// run in parallel, wait for ALL (fails fast if any rejects)
const [a, b, c] = await Promise.all([getA(), getB(), getC()]);

// wait for all, get each result OR error (never short-circuits)
const results = await Promise.allSettled([getA(), getB()]);

// the first to settle (resolve OR reject) wins
const fastest = await Promise.race([fetchPrimary(), fetchBackup()]);

// the first to FULFILL (ignores rejections until one succeeds)
const first = await Promise.any([source1(), source2()]);
```

Diese Kombinatoren drücken häufige Muster aus: `all` für paralleles Warten, `allSettled` wenn du alle Ergebnisse brauchst unabhängig von Fehlern, `race` für Timeouts/schnellster-gewinnt, `any` für Fallback-Quellen.

## setTimeout als Promise (modern)

```js
import { setTimeout as sleep } from "timers/promises";
await sleep(1000); // await a delay without wrapping in a Promise manually
```

## Warum es wichtig ist

Diese Utilities machen echten, asynchronen Node-Code sauberer und robuster: `promisify` überbrückt ältere Callback-APIs zu async/await, `AbortController` fügt Abbruch und Timeouts hinzu (verhindert hängende oder verschwendete Operationen), und die Promise-Kombinatoren (`all`/`allSettled`/`race`/`any`) drücken häufige Koordinationsmuster prägnant und korrekt aus.

Sie zu kennen ermöglicht dir, Parallelität, Abbruch und Fallback elegant zu handhaben, anstatt sie neu zu erfinden — häufige Anforderungen in jeder nicht-trivialen asynchronen Anwendung.