Koji alati pomažu pri radu s async kodom (promisify, AbortController)?

Question

Accepted Answer

Node pruža nekoliko alata koji čine async kod čistijim i više kontrolabilnim — pretvaranje starih callback API-ja u Promises, otkazivanje operacija i koordiniranje više async zadataka.

## promisify — pretvori callback API-je u 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` umota bilo koju standardnu `(args..., (err, result) => {})` callback funkciju kako bi je mogao `await` — korisno za starije knjižnice koje su prethodile Promisesima. (Mnogi built-ini sada nude promise verzije direktno, npr. `fs/promises`.)

## AbortController — otkaži async operacije

```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` pruža standardan način za **otkazivanje** operacija u letu (fetch, timeri, tokovi, mnoge knjižnice) — bitno za timeouts i izbjegavanje besmislenog rada kada rezultat više nije potreban.

## Promise kombinatori — koordiniraj više async zadataka

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

Ovi kombinatori izražavaju česte obrasce: `all` za paralelno i čekaj, `allSettled` kada vam trebaju svi ishodi bez obzira na greške, `race` za timeouts/najbrže-vođene, `any` za fallback izvore.

## setTimeout kao Promise (moderno)

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

## Zašto je važno

Ovi alati čine stvarni async Node kod čistijim i robusnijim: `promisify` premošćuje legacy callback API-je u async/await, `AbortController` dodaje otkazivanje i timeouts (sprječavajući zaglavljene ili besmislene operacije), a Promise kombinatori (`all`/`allSettled`/`race`/`any`) jasno i ispravno izražavaju česte obrasce koordinacije.

Znanjem o njima možete elegantno rukovati paralelizmom, otkazivanjem i fallback-om umjesto da ih ponovno izmišljate — česti zahtjevi u bilo kojoj netrivijalnoj async aplikaciji.