Ni zana zipi zinazosaidia kufanya kazi na msimbo wa async (promisify, AbortController)?

Question

Accepted Answer

Node hutoa zana kadhaa zinazofanya msimbo wa async kuwa safi zaidi na rahisi kudhibitiwa — kubadilisha callback APIs za zamani kuwa Promises, kughairi operesheni, na kuratibu kazi nyingi za async.

## promisify — badilisha callback APIs kuwa 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` huunganisha funguo yoyote ya kawaida ya callback `(args..., (err, result) => {})` ili uweze ku-`await` — ni muhimu kwa maktaba za zamani zilizotangulia Promises. (Built-ins nyingi sasa hutoa toleo za promise moja kwa moja, mfano `fs/promises`.)

## AbortController — ghairi operesheni za 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` hutoa njia ya kawaida ya **kughairi** operesheni zinazoendelea (fetch, timers, streams, maktaba nyingi) — ni muhimu kwa timeouts na kuepuka kazi iliyopotea wakati matokeo hayahitajiki tena.

## Promise combinators — ratibu kazi nyingi za 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()]);
```

Combinators hizi huonyesha mifumo ya kawaida: `all` kwa sambamba-na-subiri, `allSettled` unapohitaji kila tokeo bila kujali kushindwa, `race` kwa timeouts/wa kwanza-hushinda, `any` kwa vyanzo mbadala.

## setTimeout kama Promise (ya kisasa)

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

## Kwa nini ni muhimu

Zana hizi hufanya msimbo halisi wa async wa Node kuwa safi zaidi na imara: `promisify` huunganisha callback APIs za zamani na async/await, `AbortController` huongeza ughairi na timeouts (kuzuia operesheni zilizoning'inia au zilizopotea), na Promise combinators (`all`/`allSettled`/`race`/`any`) huonyesha mifumo ya kawaida ya uratibu kwa ufupi na usahihi.

Kuzijua hukuwezesha kushughulikia usambamba, ughairi, na fallback kwa ufanisi badala ya kuzitengeneza upya — mahitaji ya kawaida katika programu yoyote ya async isiyo ya kawaida.