શું સુવિધાઓ async કોડ સાથે કામ કરવામાં સહાય કરે છે (promisify, AbortController)?

Question

Accepted Answer

Node કેટલીક સુવિધાઓ પ્રદાન કરે છે જે async કોડને સ્વચ્છ અને વધુ નિયંત્રણીય બનાવે છે — જૂના callback APIs ને Promises માં રૂપાંતરિત કરવું, કામગીરી રદ કરવી, અને બહુવિધ async કાર્યો સમન્વય કરવું।

## promisify — callback APIs ને 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` કોઈપણ સામાન્ય `(args..., (err, result) => {})` callback ફંક્શનને આવરી લે છે જેથી તમે તેનું `await` કરી શકો — જૂની લાઈબ્રેરીઓ માટે ઉપયોગી જે Promises પહેલાની હોય. (ઘણા built-ins હવે સીધા promise સંસ્કરણ પ્રદાન કરે છે, દા.ત. `fs/promises`.)

## AbortController — 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` in-flight કામગીરી **રદ** કરવાનો એક માનક રસ્તો પ્રદાન કરે છે (fetch, timers, streams, ઘણી લાઈબ્રેરીઓ) — timeouts અને બરબાદ કાર્યથી બચવા માટે જરૂરી જ્યારે પરિણામની હવે જરૂર નથી.

## Promise combinators — બહુવિધ 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 સામાન્ય પેટર્ન વ્યક્ત કરે છે: `all` સમાંતર-અને-પ્રતીક્ષા માટે, `allSettled` જ્યારે તમને નિષ્ફળતા પછી પણ દરેક પરિણામ જોઈએ, `race` timeouts/સૌથી ઝડપી વિજય માટે, `any` ફરીથી પ્રયાસ સ્ત્રોતો માટે.

## setTimeout Promise તરીકે (આધુનિક)

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

## આ શા માટે મહત્વપૂર્ણ છે

એ સુવિધાઓ વાસ્તવિક-વિશ્વ async Node કોડને સ્વચ્છ અને વધુ મજબૂત બનાવે છે: `promisify` વારસાગત callback APIs ને async/await માં અનુવાદ કરે છે, `AbortController` રદ અને timeouts ઉમેરે છે (હંગ અથવા બરબાદ કામગીરી રોકવા), અને Promise combinators (`all`/`allSettled`/`race`/`any`) સામાન્ય સમન્વય પેટર્નને સંક્ષિપ્તપણે અને સાચીરીતે વ્યક્ત કરે છે.

તેમને જાણવાથી તમે સમાંતરતા, રદ, અને ફરીથી પ્રયાસને ભવ્યપણે હેન્ડલ કરી શકો છો તેના બદલે તેમને પુનઃશોધવું — કોઈપણ બિન-તુચ્છ async એપ્લિકેશનમાં સામાન્ય આવશ્યકતાઓ.