Async code-உடன் வேலை செய்ய எந்த utilities உதவுகின்றன (promisify, AbortController)?

Question

Accepted Answer

Node பல utilities-ஐ வழங்குகிறது, அவை async code-ஐ தூய்மையாகவும் கட்டுப்படுத்தக்கூடியதாகவும் ஆக்குகின்றன — பழைய callback API-களை Promises ஆக மாற்றுதல், operations-ஐ ரத்து செய்தல், மற்றும் பல async tasks-ஐ ஒருங்கிணைத்தல்.

## promisify — callback API-களை 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` எந்த standard `(args..., (err, result) => {})` callback function-ஐயும் wrap செய்கிறது, இதனால் நீங்கள் அதை `await` செய்யலாம் — Promises-க்கு முந்தைய பழைய libraries-க்கு பயனுள்ளது. (பல built-ins இப்போது promise versions-ஐ நேரடியாக வழங்குகின்றன, எ.கா. `fs/promises`.)

## AbortController — async operations-ஐ ரத்து செய்தல்

```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 operations-ஐ (fetch, timers, streams, பல libraries) **ரத்து செய்ய** ஒரு standard வழியை வழங்குகிறது — timeouts-க்கும் ஒரு முடிவு இனி தேவைப்படாதபோது வீணான வேலையைத் தவிர்ப்பதற்கும் அவசியம்.

## Promise combinators — பல async tasks-ஐ ஒருங்கிணைத்தல்

```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 பொதுவான patterns-ஐ வெளிப்படுத்துகின்றன: parallel-and-wait-க்கு `all`, தோல்விகளைப் பொருட்படுத்தாமல் ஒவ்வொரு விளைவும் தேவைப்படும்போது `allSettled`, timeouts/fastest-wins-க்கு `race`, fallback sources-க்கு `any`.

## setTimeout ஒரு Promise ஆக (நவீன)

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

## இது ஏன் முக்கியம்

இந்த utilities நிஜ-உலக async Node code-ஐ தூய்மையாகவும் robust ஆகவும் ஆக்குகின்றன: `promisify` legacy callback API-களை async/await-க்குள் இணைக்கிறது, `AbortController` ரத்து செய்தலையும் timeouts-ஐயும் சேர்க்கிறது (தொங்கும் அல்லது வீணான operations-ஐத் தடுக்கிறது), மற்றும் Promise combinators (`all`/`allSettled`/`race`/`any`) பொதுவான ஒருங்கிணைப்பு patterns-ஐ சுருக்கமாகவும் சரியாகவும் வெளிப்படுத்துகின்றன.

அவற்றை அறிந்துகொள்வது parallelism, ரத்து செய்தல், மற்றும் fallback-ஐ அவற்றை மீண்டும் கண்டுபிடிப்பதற்குப் பதிலாக நேர்த்தியாகக் கையாள உங்களை அனுமதிக்கிறது — எந்த சாதாரணமற்ற async application-ிலும் பொதுவான தேவைகள்.