Ce utilitare ajută la lucrul cu codul asincron (promisify, AbortController)?

Question

Accepted Answer

Node oferă mai multe utilitare care fac codul asincron mai curat și mai controlabil — convertind API-uri callback vechi în Promises, anulând operații și coordonând mai multe sarcini asincrone.

## De ce conteaza

```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` încapsulează orice funcție callback standard `(args..., (err, result) => {})` pentru ca să o poți `await`a — util pentru biblioteci mai vechi care preced Promises. (Multe funcții built-in oferă acum versiuni promise direct, de ex. `fs/promises`.)

## AbortController — anulează operații asincrone

```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` oferă o modalitate standard de a **anula** operații în curs (fetch, timere, fluxuri, multe biblioteci) — esențial pentru timeout-uri și pentru a evita munca risipă atunci când un rezultat nu mai este necesar.

## Promise combinators — coordonează mai multe sarcini asincrone

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

Acești combinatori exprimă modele comune: `all` pentru paralel-și-așteptare, `allSettled` când ai nevoie de fiecare rezultat indiferent de eșecuri, `race` pentru timeout-uri/câștigător-cel-mai-rapid, `any` pentru surse de rezervă.

## setTimeout ca Promise (modern)

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

## De ce conteaza

Aceste utilitare fac codul Node asincron din lumea reală mai curat și mai robust: `promisify` conectează API-uri callback vechi în async/await, `AbortController` adaugă anulare și timeout-uri (prevenind operații blocate sau risipite), iar combinatorii Promise (`all`/`allSettled`/`race`/`any`) exprimă modele comune de coordonare pe scurt și corect.

Cunoașterea lor te permite să gestionezi paralelismul, anularea și fallback cu eleganță în loc să le reinventezi — nevoi comune în orice aplicație asincronă non-trivială.