Quels utilitaires aident au travail avec du code asynchrone (promisify, AbortController) ?

Question

Accepted Answer

Node fournit plusieurs utilitaires qui rendent le code asynchrone plus propre et plus contrôlable — convertir les anciennes API basées sur les callbacks en Promises, annuler les opérations et coordonner plusieurs tâches asynchrones.

## promisify — convertir les API callback en 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` encapsule toute fonction callback standard `(args..., (err, result) => {})` pour que vous puissiez l'`await` — utile pour les anciennes bibliothèques antérieures aux Promises. (Beaucoup de fonctions intégrées offrent maintenant des versions promise directement, par exemple `fs/promises`.)

## AbortController — annuler les opérations asynchrones

```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` fournit un moyen standard d'**annuler** les opérations en vol (fetch, timers, streams, de nombreuses bibliothèques) — essentiel pour les timeouts et pour éviter le travail inutile quand un résultat n'est plus nécessaire.

## Combinateurs Promise — coordonner plusieurs tâches asynchrones

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

Ces combinateurs expriment des schémas courants : `all` pour l'exécution parallèle et attendre, `allSettled` quand vous avez besoin de chaque résultat indépendamment des échecs, `race` pour les timeouts/le plus rapide gagne, `any` pour les sources de secours.

## setTimeout en tant que Promise (moderne)

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

## Pourquoi c'est important

Ces utilitaires rendent le code asynchrone du monde réel dans Node plus propre et plus robuste : `promisify` relie les anciennes API callback dans async/await, `AbortController` ajoute l'annulation et les timeouts (prévenant les opérations figées ou inutiles), et les combinateurs Promise (`all`/`allSettled`/`race`/`any`) expriment les schémas de coordination courants de manière concise et correcte.

Les connaître vous permet de gérer le parallélisme, l'annulation et les solutions de secours avec élégance au lieu de les réinventer — des besoins courants dans toute application asynchrone non triviale.

promisify — convertir les API callback en Promises

AbortController — annuler les opérations asynchrones

Combinateurs Promise — coordonner plusieurs tâches asynchrones

setTimeout en tant que Promise (moderne)

Pourquoi c'est important

question.related