Welke utilities helpen met async code (promisify, AbortController)?

Question

Accepted Answer

Node biedt verschillende utilities die async code schoner en controlleerbaarder maken — het converteren van oude callback API's naar Promises, het annuleren van operaties en het coördineren van meerdere async taken.

## promisify — callback API's naar Promises converteren

```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` verpakt elke standaard `(args..., (err, result) => {})` callback-functie zodat je deze kunt `await` — nuttig voor oudere bibliotheken die voorafgaand aan Promises zijn ontworpen. (Veel ingebouwde functies bieden nu rechtstreeks promise-versies, bijv. `fs/promises`.)

## AbortController — async operaties annuleren

```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` biedt een standaardmanier om in-flight operaties **annuleren** (fetch, timers, streams, veel bibliotheken) — essentieel voor timeouts en het voorkomen van verspilde werk wanneer een resultaat niet meer nodig is.

## Promise combinators — meerdere async taken coördineren

```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()]);
```

Deze combinators drukken gangbare patronen uit: `all` voor parallel-en-wachten, `allSettled` wanneer je elke uitkomst nodig hebt ondanks fouten, `race` voor timeouts/snelste-wint, `any` voor fallback-bronnen.

## setTimeout als Promise (modern)

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

## Waarom het belangrijk is

Deze utilities maken real-world async Node code schoner en robuuster: `promisify` verbindt verouderde callback API's met async/await, `AbortController` voegt annulering en timeouts toe (voorkoming van hangen of verspilde operaties), en de Promise combinators (`all`/`allSettled`/`race`/`any`) drukken gangbare coördinatiepatronen bondig en correct uit.

Door ze te kennen kun je parallelisme, annulering en fallback elegant hanteren in plaats van ze opnieuw uit te vinden — veel voorkomende behoeften in elke niet-triviale async-toepassing.