Cad iad na fóntas a chabhrítear le cód neamhshioncronach (promisify, AbortController)?

Question

Accepted Answer

Soláthraíonn Node roinnt ionstraimí a dhéanann cód neamhshioncronach níos geal agus níos inrialúla — ag tiontú API seanfhashanta callbacks go Promises, ag cealú oibríochtaí, agus ag comhordú gníomhaíochtaí async iolrach.

## promisify — APIs callback a thiontú go 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
```

Baineann `promisify` aon fheidhm `(args..., (err, result) => {})` callback caighdeánach ionas gur féidir leat `await` a dhéanamh uirthi — úsáideach d'leabharlanna níos sine a thuilleadh ar Promises. (Tugann go leor built-ins leagain promise anois go díreach, m.sh. `fs/promises`.)

## AbortController — oibríochtaí async a chealú

```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");
}
```

Soláthraíonn `AbortController` bealach caighdeánach chun **cancel** a dhéanamh ar oibríochtaí in-flight (fetch, timers, streams, go leor leabharlanna) — riachtanach do thuairimí-amach agus cosc a chur ar obair spréachta nuair nach bhfuiltear ag gabhálann le toradh níos mó.

## Promise combinators — gníomhaíochtaí async iolrach a chomhordú

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

Cuireann na combinators seo patrúin choitianta in iúl: `all` do bheirirt-agus-fanaigh, `allSettled` nuair is gá gach toradh a bheith agat beag beann ar bhocht, `race` do thuairimí-amach/bua-is-tapa, `any` do fhoinsí gealltanais.

## setTimeout mar Promise (nua-aimseartha)

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

## Cén fáth a bhfuil sé i bhfeidhm

Déanann na ionstraimí seo cód async fíor-dhomhanda Node níos geal agus níos cobhsaí: déanann `promisify` droichead a dhéanamh ar APIs legacy callback isteach i async/await, cuireann `AbortController` cealúchán agus tuairimí-amach (ag cosc oibríochtaí chrochta nó bharraithe), agus cuireann an Promise combinators (`all`/`allSettled`/`race`/`any`) patrúin chomhordúcháin choitianta in iúl go geal agus go ceart.

Tugann eolas orthu duit parallelism, cealúchán, agus gealltanais a láimhseáil go galanta in ionad iad a athadhúradh — riachtanais choitianta in aon fheidhmchlár async neamhfhánach.