Jakie narzędzia pomagają pracować z kodem asynchronicznym (promisify, AbortController)?

Question

Accepted Answer

Node zapewnia kilka narzędzi, które czynią kod asynchroniczny czystszym i bardziej kontrolowalnym — konwersją starych callback API na Promises, anulowaniem operacji oraz koordynacją wielu zadań asynchronicznych.

## Dlaczego to ważne

```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` opakowuje dowolną standardową funkcję callback `(args..., (err, result) => {})` aby można było ją `await`ować — przydatne dla starszych bibliotek poprzedzających Promises. (Wiele wbudowanych funkcji oferuje teraz wersje promise bezpośrednio, np. `fs/promises`.)

## AbortController — anuluj operacje asynchroniczne

```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` zapewnia standardowy sposób **anulowania** operacji w toku (fetch, timery, strumienie, wiele bibliotek) — niezbędny dla timeoutów i unikania zmarnowanej pracy, gdy wynik nie jest już potrzebny.

## Promise combinators — koordynuj wiele zadań asynchronicznych

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

Te kombinatory wyrażają typowe wzorce: `all` dla równoległo-i-czekaj, `allSettled` gdy potrzebujesz każdego wyniku niezależnie od błędów, `race` dla timeoutów/najszybszych zwycięzców, `any` dla źródeł zapasowych.

## setTimeout jako Promise (nowoczesne)

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

## Dlaczego to ważne

Te narzędzia czynią rzeczywisty asynchroniczny kod Node czystszym i bardziej niezawodnym: `promisify` łączy stare callback API w async/await, `AbortController` dodaje anulowanie i timeouty (zapobiegając zawieszeniu lub zmarnowanym operacjom), a kombinatory Promise (`all`/`allSettled`/`race`/`any`) wyrażają typowe wzorce koordynacji zwięźle i poprawnie.

Znajomość ich pozwala elegancko obsługiwać paralelizm, anulowanie i fallback zamiast je wymyślać od nowa — typowe potrzeby każdej nietrywialnej aplikacji asynchronicznej.