Cilat utilitete ndihmojnë në punën me kod asinkron (promisify, AbortController)?

Question

Accepted Answer

Node siguron disa utilitet që e bëjnë kodin asinkron më të pastër dhe më të kontrollueshem — konvertimin e API-ve callback të vjetra në Promises, anulimin e operacioneve dhe koordinimin e detyrave të shumta asinkrone.

## Pse ka rëndësi

```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` përplas çdo funksion callback standard `(args..., (err, result) => {})` në mënyrë që të mund ta `await`osh — e dobishme për biblioteka më të vjetra që paraprijnin Promises. (Shumë funksione të ndërtuar-në tani ofrojnë versione promise drejtpërsëdrejti, p.sh. `fs/promises`.)

## AbortController — anulo operacionet asinkrone

```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` siguron një mënyrë standarde për të **anuluar** operacionet në fluks (fetch, timera, rrjedha, shumë biblioteka) — e domosdoshme për timeout-et dhe shmangia e punës të shpenzuar kur një rezultat nuk është më i nevojshëm.

## Promise combinators — koordino detyra të shumta asinkrone

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

Këta kombinatorë shprehin modele të zakonshme: `all` për paralel-dhe-prit, `allSettled` kur ke nevojë çdo rezultati pavarësisht nga dështimet, `race` për timeout-et/fitues-më-i-shpejt, `any` për burime rezervë.

## setTimeout si Promise (moderne)

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

## Pse ka rëndësi

Këto utilitet e bëjnë kodin asinkron Node të botës reale më të pastër dhe më të fuqishëm: `promisify` lidh API-et callback të vjetra në async/await, `AbortController` shton anulim dhe timeout-e (parandalon operacionet e varura ose të shpenzuara), dhe kombinatorët Promise (`all`/`allSettled`/`race`/`any`) shprehin modele të zakonshme koordinimi në mënyrë të përmbledhur dhe të saktë.

Dija e tyre të lejon të trajtosh paralelizmin, anulimin dhe fallback-un në mënyrë elegante në vend që t'i shpikesh përsëri — nevojat e zakonshme në çdo aplikacion asinkron jo-të-parëndësishëm.