Vilka verktyg hjälper till att arbeta med asynkron kod (promisify, AbortController)?

Question

IT Interview Practice · Accepted Answer

Node tillhandahåller flera verktyg som gör asynkron kod renare och mer kontrollerbar — konvertering av gamla callback-API:er till Promises, avbrytande av operationer och koordinering av flera asynkrona uppgifter.

## promisify — konvertera callback-API:er till Promises

```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` omsluter vilken som helst standard `(args..., (err, result) => {})` callback-funktion så att du kan `await` den — användbar för äldre bibliotek som föregår Promises. (Många inbyggda alternativ erbjuder nu promise-versioner direkt, t.ex. `fs/promises`.)

## AbortController — avbryt asynkrona operationer

```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` tillhandahåller ett standardiserat sätt att **avbryta** pågående operationer (fetch, timers, streams, många bibliotek) — väsentligt för timeouts och för att undvika slösat arbete när ett resultat inte längre behövs.

## Promise-kombinatorer — koordinera flera asynkrona uppgifter

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

Dessa kombinatorer uttrycker vanliga mönster: `all` för parallell-och-vänta, `allSettled` när du behöver varje resultat oavsett fel, `race` för timeouts/snabbast-vinner, `any` för reservkällor.

## setTimeout som en Promise (modern)

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

## Varför det är viktigt

Dessa verktyg gör verklig asynkron Node-kod renare och mer robust: `promisify` överbryggar äldre callback-API:er till async/await, `AbortController` lägger till avbrytande och timeouts (förhindrar hängande eller slösat arbete), och Promise-kombinatorerna (`all`/`allSettled`/`race`/`any`) uttrycker vanliga koordineringsmönster på ett kortfattat och korrekt sätt.

Att känna till dem gör att du kan hantera parallellism, avbrytande och reservplaner elegant istället för att uppfinna dem på nytt — vanliga behov i alla icke-triviala asynkrona applikationer.

promisify — konvertera callback-API:er till Promises

AbortController — avbryt asynkrona operationer

Promise-kombinatorer — koordinera flera asynkrona uppgifter

setTimeout som en Promise (modern)

Varför det är viktigt

Relaterade frågor