Jaké utility pomáhají pracovat s async kódem (promisify, AbortController)?

Question

Accepted Answer

Node poskytuje několik utility, které činí async kód čistším a lépe kontrolovatelným — konverzi starých callback API na Promise, zrušení operací a koordinaci více async úloh.

## promisify — konverze callback API na Promise

```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` obalí jakoukoli standardní callback funkci `(args..., (err, result) => {})` tak, abyste ji mohli `await` — užitečné pro starší knihovny, které předcházely Promise. (Mnoho vestavěných funkcí nyní nabízí verze s Promise přímo, např. `fs/promises`.)

## AbortController — zrušení async operací

```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` poskytuje standardní způsob, jak **zrušit** operace v letu (fetch, timery, streamy, mnoho knihoven) — nezbytné pro timeouty a vyhnutí se zbytečné práci, když už výsledek není potřebný.

## Promise kombinátory — koordinace více async úloh

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

Tyto kombinátory vyjadřují běžné vzory: `all` pro paralelní čekání, `allSettled` když potřebujete každý výsledek bez ohledu na selhání, `race` pro timeouty/nejrychlejší variantu, `any` pro záložní zdroje.

## setTimeout jako Promise (moderní)

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

## Proč je to důležité

Tyto utility činí reálný async Node kód čistším a robustnějším: `promisify` propojuje starší callback API do async/await, `AbortController` přidává zrušení a timeouty (zabraňující zavěšeným nebo zbytečným operacím), a Promise kombinátory (`all`/`allSettled`/`race`/`any`) vyjadřují běžné koordinační vzory stručně a správně.

Jejich znalost vám umožní elegantně zvládat paralelismus, zrušení a náhradní řešení místo jejich vymýšlení — běžné potřeby v jakékoli netriviální async aplikaci.