ਕਿਹੜੀਆਂ utilities async ਕੋਡ ਨਾਲ ਕਰਤ ਵਿੱਚ ਮਦਦ ਕਰਦੀਆਂ ਹਨ (promisify, AbortController)?

Question

Accepted Answer

Node ਕਈ utilities ਫ਼ਰਾਹਮ ਕਰਦਾ ਹੈ ਜੋ async ਕੋਡ ਨੂੰ ਸਾਫ਼ ਅਤੇ ਵਧੇਰੇ ਕਾਬੂ ਯੋਗ ਬਣਾਉਂਦੀਆਂ ਹਨ — ਪੁਰਾਣੇ callback APIs ਨੂੰ Promises ਵਿੱਚ ਬਦਲਣਾ, ਓਪਰੇਸ਼ਨ ਨੂੰ ਰੱਦ ਕਰਨਾ, ਅਤੇ ਕਈ async ਕਾਮਾਂ ਨਾਲ ਮੇਲ ਕਰਨਾ।

## ਆਖਰ ਕਿਉਂ ਮਹੱਤਵਪੂਰਨ ਹੈ

```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` ਕਰ ਸਕੋ — ਪੁਰਾਣੀਆਂ libraries ਲਈ ਮਦਦਗਾਰ ਜੋ 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` ਅਸਲ ਵਿੱਚ ਚਲਦੇ ਓਪਰੇਸ਼ਨ **ਰੱਦ** ਕਰਨ ਦਾ ਇੱਕ ਮਿਆਰੀ ਤਰੀਕਾ ਫ਼ਰਾਹਮ ਕਰਦਾ ਹੈ (fetch, timers, streams, ਬਹੁਤ ਸਾਰੀਆਂ libraries) — 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 ਆਮ patterns ਦਾ ਪ੍ਰਗਟਾਵਾ ਕਰਦੇ ਹਨ: `all` ਸਮਾਨਾਂਤਰ ਤੇ ਉਡਾ ਦਿਓ ਲਈ, `allSettled` ਜਦੋਂ ਤੁਹਾਨੂੰ ਹਰ ਨਤੀਜਾ ਪ੍ਰਚੋ ਤੋਂ ਬਚਾਓ ਲਈ ਚਾਹੀਦਾ ਹੋਵੇ, `race` timeouts/fastest-wins ਲਈ, `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 ਕੋਡ ਨੂੰ ਸਾਫ਼ ਅਤੇ ਵਧੇਰੇ ਮਜ਼ਬੂਤ ਬਣਾਉਂਦੀਆਂ ਹਨ: `promisify` ਪੁਰਾਣੇ callback APIs ਨੂੰ async/await ਵਿੱਚ ਸੇਤੂ ਬਣਾਉਂਦਾ ਹੈ, `AbortController` cancellation ਅਤੇ timeouts ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ (ਹੱਗੇ ਜਾਂ ਬਰਬਾਦ ਓਪਰੇਸ਼ਨਾਂ ਤੋਂ ਬਚਾਉਂਦਾ ਹੈ), ਅਤੇ Promise combinators (`all`/`allSettled`/`race`/`any`) ਸਾਧਾਰਣ ਮੇਲ patterns ਨੂੰ ਸੰਖਿਪਤ ਤਰੀਕਿਆਂ ਨਾਲ ਪ੍ਰਗਟਾਉਂਦੇ ਹਨ।

ਉਨ੍ਹਾਂ ਨੂੰ ਜਾਨਨਾ ਤੁਹਾਨੂੰ parallelism, cancellation, ਅਤੇ ਬੈਕਅਪ ਨੂੰ ਸੌਖਾ ਤਰੀਕਿਆਂ ਨਾਲ ਸੰਭਾਲਣ ਦਿੰਦਾ ਹੈ ਬਜਾਏ ਉਨ੍ਹਾਂ ਨੂੰ ਦੁਬਾਰਾ ਈਜਾਦ ਕਰਨ ਦਾ — ਕਿਸੇ ਵੀ ਗੈਰ-ਮਾਮੂਲੀ async ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਆਮ ਲੋੜਾਂ।