Hvilke verktøy hjelper til med asynkron kode (promisify, AbortController)?

Question

Accepted Answer

Node tilbyr flere verktøy som gjør asynkron kode renere og mer kontrollérbar — konvertering av gamle callback-APIer til Promises, avbrytelse av operasjoner, og koordinering av flere asynkrone oppgaver.

## Hvorfor det er viktig

```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` pakker inn hvilken som helst standard `(args..., (err, result) => {})` callback-funksjon slik at du kan `await` den — nyttig for eldre biblioteker som forut Promises. (Mange built-ins tilbyr nå promise-versjoner direkte, f.eks. `fs/promises`.)

## AbortController — avbryt asynkrone operasjoner

```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` gir en standard måte å **avbryte** operasjoner i gang (fetch, timere, streams, mange biblioteker) — essensielt for timeouts og for å unngå bortkastet arbeid når et resultat ikke lenger er nødvendig.

## Promise-kombinatorer — koordiner flere asynkrone oppgaver

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

Disse kombinatorene uttrykker vanlige mønstre: `all` for parallell-og-vent, `allSettled` når du trenger hvert resultat uavhengig av feil, `race` for timeouts/raskeste-vinner, `any` for reserve-kilder.

## setTimeout som en Promise (moderne)

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

## Hvorfor det er viktig

Disse verktøyene gjør virkelig asynkron Node-kode renere og mer robust: `promisify` bygger bro mellom gamle callback-APIer inn i async/await, `AbortController` legger til avbrytelse og timeouts (forhindrer hengende eller bortkastet operasjoner), og Promise-kombinatorene (`all`/`allSettled`/`race`/`any`) uttrykker vanlige koordineringsmønstre kortfattet og korrekt.

Å kjenne dem lar deg håndtere parallelisme, avbrytelse, og reserve elegant i stedet for å finne dem opp på nytt — vanlige behov i enhver ikke-triviell asynkron applikasjon.