Kateri programi pomagajo pri delu z asynchronim kodom (promisify, AbortController)?

Question

Accepted Answer

Node zagotavlja več pripomočkov, ki asynchroni kod naredijo čistejšega in bolj obvladljivega — pretvarjanje starih callback API-jev v Promises, preklic operacij in usklajevano izvajanje več asynchronih nalog.

## Zakaj je to pomembno

```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` ovije kateri koli standardni callback funkcijo `(args..., (err, result) => {})` tako, da jo lahko `await`ate — uporabno za starejše knjižnice, ki so předhodile Promises. (Mnoge vgrajene funkcije sedaj direktno ponujajo verzije promise, npr. `fs/promises`.)

## AbortController — preklic asynchronih operacij

```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` zagotavlja standardni način za **preklic** operacij v teku (fetch, tajmerji, tokovi, številne knjižnice) — bistvenega za časovne omejitve in izogibanje zapravljenemu delu, ko rezultat ni več potreben.

## Promise combinators — uskladi več asynchronih nalog

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

Ti kombinatorji izražajo skupne vzorce: `all` za vzporedno-in-čakaj, `allSettled` ko potrebuješ vsak rezultat ne glede na napake, `race` za časovne omejitve/najhitrejši-zmagovalec, `any` za varnostne vire.

## setTimeout kot Promise (sodoben)

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

## Zakaj je to pomembno

Ti pripomočki naredijo resnični asynchroni Node kod čistejšega in bolj robustnega: `promisify` povezuje stare callback API-je v async/await, `AbortController` dodaja preklic in časovne omejitve (preprečuje obešene ali zapravljene operacije), kombinatorji Promise (`all`/`allSettled`/`race`/`any`) pa stisneto in pravilno izražajo skupne vzorce usklajevanja.

Znanje njih vam omogoča, da elegantno upravljate paralelizem, preklic in fallback namesto njihovega ponovnega izuma — pogosta potreba v vsakem netrivialnem asynchronem programu.