Quali utility aiutano a lavorare con il codice async (promisify, AbortController)?

Question

Accepted Answer

Node fornisce diversi utility che rendono il codice async più pulito e controllabile — convertendo vecchie API callback in Promises, annullando operazioni e coordinando più attività async.

## promisify — converti API callback in 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` avvolge qualsiasi funzione callback standard `(args..., (err, result) => {})` in modo da poterla `await` — utile per librerie più vecchie precedenti a Promises. (Molti built-in ora offrono versioni promise direttamente, ad es. `fs/promises`.)

## AbortController — annulla operazioni async

```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` fornisce un modo standard per **annullare** operazioni in corso (fetch, timer, stream, molte librerie) — essenziale per i timeout e per evitare lavoro inutile quando il risultato non è più necessario.

## Promise combinators — coordina più attività async

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

Questi combinatori esprimono modelli comuni: `all` per parallelo-e-attesa, `allSettled` quando hai bisogno di ogni risultato indipendentemente dai fallimenti, `race` per timeout/vincitori-più-veloci, `any` per fonti di fallback.

## setTimeout come Promise (moderno)

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

## Perché è importante

Questi utility rendono il codice async Node del mondo reale più pulito e robusto: `promisify` crea un ponte tra le vecchie API callback e async/await, `AbortController` aggiunge annullamento e timeout (prevenendo operazioni bloccate o inutili), e i Promise combinators (`all`/`allSettled`/`race`/`any`) esprimono modelli di coordinazione comuni in modo conciso e corretto.

Conoscerli ti permette di gestire parallelismo, annullamento e fallback elegantemente invece di reinventarli — esigenze comuni in qualsiasi applicazione async non banale.