Mitkä apuohjelmat auttavat asynkronisen koodin kanssa (promisify, AbortController)?

Question

Accepted Answer

Node tarjoaa useita apuohjelmia, jotka tekevät asynkronisesta koodista puhtaampaa ja hallittavampaa — vanhojen callback-sovellusliittymien muuntaminen Promiseiksi, operaatioiden peruuttaminen ja useiden asynkronisten tehtävien koordinointi.

## promisify — muunna callback-sovellusliittymät Promiseiksi

```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` kääri minkä tahansa standardin `(args..., (err, result) => {})` callback-funktion niin että voit käyttää `await`ia sen kanssa — hyödyllinen vanhemmille kirjastoille, jotka ovat ennen Promiseita. (Monet sisäänrakennetut osat tarjoavat nyt suoraan promise-versioita, esim. `fs/promises`.)

## AbortController — peruuta asynkroniset operaatiot

```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` tarjoaa vakiintuneen tavan **peruuttaa** käynnissä olevat operaatiot (fetch, ajastimet, streamit, monet kirjastot) — välttämätön aikakatkaisuille ja turhan työn välttämiselle, kun tulosta ei enää tarvita.

## Promise-kombinaattorit — koordinoi useita asynkronisia tehtäviä

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

Nämä kombinaattorit ilmaisevat yleisiä malleja: `all` rinnakkaiselle odottamiselle, `allSettled` kun tarvitset jokaisen tuloksen riippumatta virheistä, `race` aikakatkaisuille/nopeimmille voittajille, `any` varalähteiden saamiseksi.

## setTimeout Promise-muodossa (moderni)

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

## Miksi sillä on merkitystä

Nämä apuohjelmat tekevät todellisen maailman asynkronisesta Node-koodista puhtaampaa ja kestävempää: `promisify` yhdistää legacy callback-sovellusliittymät async/await-koodiin, `AbortController` lisää peruutus- ja aikakatkaisumahdollisuudet (estäen jumittuneet tai turhat operaatiot), ja Promise-kombinaattorit (`all`/`allSettled`/`race`/`any`) ilmaisevat yleiset koordinointimallit ytimekkäästi ja oikein.

Niiden tunteminen antaa sinulle mahdollisuuden käsitellä rinnakkaisuutta, peruuttamista ja varalähteitä tyylikkäästi sen sijaan, että keksit ne uudelleen — yleiset tarpeet kaikissa ei-triviaaleissa asynkronisissa sovelluksissa.