Déan comparáid idir callbacks, Promises agus async/await.

Question

Accepted Answer

Siad seo trí ghlúin de dhéileáil le hoibríochtaí **neamhshíneach** i Node — gach ceann ag feabhas ar inléiteacht thar an gcinn roimhe, ach ar fad tógtha ar an bhunús event-loop céanna.

## 1. Callbacks — an bunaidh (agus "callback hell")

```js
fs.readFile("a.txt", (err, a) => {
  if (err) return handle(err);            // error-first callback convention
  fs.readFile("b.txt", (err, b) => {       // nesting deepens with each step...
    if (err) return handle(err);
    db.save(a + b, (err) => {              // "pyramid of doom"
      if (err) return handle(err);
    });
  });
});
```

Is é gnás Node ná **error-first callbacks** (`(err, result)`). Oibríonn siad ach brúnn siad go domhain agus scaipeann siad láimhseáil earráide — deacair a léamh agus a choinneáil.

## 2. Promises — inslábhaofa, foluain níos geal

```js
readFile("a.txt")
  .then(a => readFile("b.txt").then(b => a + b)) // return a promise → chain waits
  .then(combined => db.save(combined))
  .catch(handle);                                 // ONE place for all errors
```

Déanann Promise ionadaíocht ar luach sa todhchaí; slabhraíonn `.then` céimeanna agus láimhsíonn `.catch` aon earráid sa slabhra — níos foluain ná callbacks foluainithe.

## 3. async/await — cosúil go sincronach (an réamhshocrú nua-aimseartha)

```js
async function combine() {
  try {
    const a = await readFile("a.txt");   // pause until resolved
    const b = await readFile("b.txt");
    await db.save(a + b);
  } catch (err) {
    handle(err);                          // normal try/catch works
  }
}
```

Is siúcra comhréire thar Promises an `async/await` — léitear ó bharr go bun cosúil le cód sincronach, úsáideann sé gnáth `try/catch`, agus is é an stíl nua-aimseartha a mholtar.

## Ná seriailíonn obair neamhspleách

```js
// ❌ sequential — slow
const a = await getA(); const b = await getB();
// ✅ parallel — both at once
const [a, b] = await Promise.all([getA(), getB()]);
```

## An gaol

```text
Callbacks → Promises → async/await
All use the event loop. Promises wrap callbacks; async/await wraps Promises.
Modern code: async/await, with Promise.all to parallelize independent ops.
```

## Cén fáth a bhíonn tábhacht ann

Is doimmhéanach láimhseáil Async i Node (tá gach I/O neamhshíneach).

Tuiscint ar an dul chun cinn — callbacks error-first (fós coitianta i seanAPIanna/leabharlanna), Promises (inslábhaofa) agus async/await (inléite, réamhshocrúite) — tugann sé duit aon chódbhunús a léamh agus loighic gheal neamhshíneach a scríobh.

A bheith ar an eolas go bhfuil siad ar fad mar an méine event-loop céanna fúinn, agus a bheith i gcuimhne duit oibríochtaí neamhspleácha a chur go páralléil le `Promise.all`, is iad seo na heochracha do chóid Node neamhshíneach ceart agus éifeachtach.