Mely segédprogramok segítik az async kód kezelését (promisify, AbortController)?

Question

Accepted Answer

A Node számos olyan segédprogramot biztosít, amelyek tisztábbá és vezérelhetőbbé teszik az async kódot — a régi callback API-kat Promise-okká alakítva, műveletek törlésével és több async feladat koordinálásával.

## promisify — callback API-k átalakítása Promise-okká

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

A `promisify` burkolja az `(args..., (err, result) => {})` standard callback függvényt, így `await`-el tudod használni — hasznos a Promise-ok előtti régebbi könyvtárakhoz. (Sok beépített funkciónak most már közvetlenül van promise verziója, például `fs/promises`.)

## AbortController — async műveletek törlése

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

Az `AbortController` standard módot biztosít a **törlésre** repülésben lévő műveleteknél (fetch, timers, streams, sok könyvtár) — lényeges a timeoutokhoz és a felesleges munka elkerüléséhez, amikor az eredményre már nincs szükség.

## Promise kombinátorok — több async feladat koordinálása

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

Ezek a kombinátorok gyakori mintákat fejeznek ki: `all` párhuzamos-és-várakozás esetén, `allSettled` ha minden kimenetelt kell, függetlenül a hibáktól, `race` timeoutok/leggyorsabb-nyertesek esetén, `any` fallback forrásokhoz.

## setTimeout Promise-ként (modern)

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

## Miért fontos

Ezek a segédprogramok a valós async Node kódot tisztábbá és robusztusabbá teszik: `promisify` örökölt callback API-kat híd át az async/await-be, `AbortController` törlést és timeoutot ad (megakadályozva az akadozó vagy felesleges műveletet), az Promise kombinátorok (`all`/`allSettled`/`race`/`any`) pedig tömören és helyesen fejezik ki a gyakori koordinációs mintákat.

Ismertségükkel elegánsan kezelheted a párhuzamosságot, törlést és fallback-et ahelyett, hogy újra feltalálnád őket — bármelyik nem triviális async alkalmazás szokásos igénye.