Conas a oibríonn async/await?

Question

Accepted Answer

`async/await` is **syntax sugar over Promises** a ligfeadh duit cód eatramhach a scríobh a léann cosúil le cód sioncronach. Tugann feidhm `async` Promise i gcónaí; `await` stopann an fheidhm go dtí go socrú Promhise, ansin cuirtear ar siúl arís le a luach.

```js
async function loadUser(id) {
  try {
    const res = await fetch(`/api/users/${id}`); // pause until the response
    const user = await res.json();               // pause until parsed
    return user;                                  // becomes the resolved value
  } catch (err) {
    console.error(err); // catches rejections from any await above
  }
}
```

## Seicheamhach vs comhpháirteach — earráid dhóchúlachta choiteann

`await` ritheann rudaí **ceann i ndiaidh a chéile**. Mura bhfuil dhá iarratas ag brath ar a chéile, a bheith ag feitheamh orthu in ord is lag go mall:

```js
// ❌ sequential — total time = a + b
const a = await getA();
const b = await getB();

// ✅ parallel — total time = max(a, b)
const [a, b] = await Promise.all([getA(), getB()]);
```

## Láimhseáil earráidí

Baineann úsáid as `try/catch` in ionad `.catch`. Chaitheann Promhise díultaithe atá feidhmithe `await`, ionas go bhfuil ceann `catch` clúdaithe an bhloc ar fad.

## Faoi an bhonnsprioc

Is fós é Promises agus an fiú microtask — ní bhloigheann `await` an snáithe; tugann sé rialú ionas go ritheann cód eile, ansin cuirtear ar siúl arís. Ná déan dearmad: glaoch ar fheidhm `async` gan a bheith ag `await` (nó `.catch`) air is féidir earráidí a dhéanamh i bhfolach.

## Cén fáth a bhíonn sé tábhachtach

Déanann sé sreabhadh eatramhach inléite agus is an réamhshocrúchán nua-aimseartha é do sraith-chur oibre eatramhach — ach caithfidh tú go gníomhach a dhéanamh araonta ar oibríochtaí neamhspleách le `Promise.all`.