అసింక్రోనస్ కోడ్‌తో పని చేయడానికి సహాయపడే యూటిలిటీలు ఏవి (promisify, AbortController)?

Question

Accepted Answer

Node అసింక్రోనస్ కోడ్‌ను శుద్ధిగా మరియు మరింత నియంత్రించదగినవిగా చేసే అనేక యూటిలిటీలను అందిస్తుంది — పూర్వపు కాల్‌బ్యాక్ API లను Promises లకు మార్చడం, ఆపరేషన్‌లను రద్దు చేయడం, మరియు బహుళ అసింక్రోనస్ టాస్క్‌లను సమన్వయం చేయడం.

## promisify — callback APIలను Promiseslకు మార్చండి

```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) => {})` కాల్‌బ్యాక్ ఫంక్షన్‌ను wrap చేస్తుంది తద్వారా మీరు దానిని `await` చేయవచ్చు — Promises కు ముందు ఉన్న పాత లైబ్రరీల కోసం ఉపయోగకరంగా ఉంటుంది. (అనేక built-ins ఇప్పుడు promise సంస్కరణలను నేరుగా అందిస్తాయి, ఉదా. `fs/promises`.)

## AbortController — అసింక్రోనస్ ఆపరేషన్‌లను రద్దు చేయండి

```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 — బహుళ అసింక్రోనస్ టాస్క్‌లను సమన్వయం చేయండి

```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
```

## ఇది ఎందుకు ముఖ్యమైనది

ఈ యూటిలిటీలు వాస్తవ-ప్రపంచ అసింక్రోనస్ Node కోడ్‌ను శుద్ధిగా మరియు మరింత దృఢంగా చేస్తాయి: `promisify` పూర్వపు కాల్‌బ్యాక్ APIలను async/await లకు సంధించે, `AbortController` రద్దు చేయడం మరియు timeouts (హ్యాంగ్ లేదా వృథా ఆపరేషన్‌లను నిరోధించడం) జోడిస్తుంది, మరియు Promise combinators (`all`/`allSettled`/`race`/`any`) సాధారణ సమన్వయ నమూనాలను సంక్షిప్తంగా మరియు సరిగ్గా వ్యక్తపరుస్తాయి.

వాటిని తెలుసుకోవడం సమాంతరవాదం, రద్దు చేయడం, మరియు ఫాల్‌బ్యాక్‌ను సొగసుగా నిర్వహించటానికి వీలు చేస్తుంది — ఏదైనా నిరాడంబర అసింక్రోనస్ అప్లికేషన్‌లో సాధారణ చాహనలు.