Conas a dhéanann tú earráidí a láimhseáil i gcód async Node?

Question

Accepted Answer

Bíonn an láimhseáil earráidí difriúil ag brath ar an stíl async, agus má dhéanann tú botún air is dócha go mbeidh faillí i bhfolach nó cliseadh ann. Na rialacha príomhúla: `try/catch` a úsáid le async/await, ionchur Dúshlánaithe Promise a láimhseáil i gcónaí, agus ná lig go n-éalaí earráidí i n-asymptotic callbacks gan láimhseáil.

## async/await — úsáid try/catch

```js
async function getUser(id) {
  try {
    const user = await db.findUser(id);   // a rejection here throws into catch
    return user;
  } catch (err) {
    logger.error(err);
    throw new AppError("Failed to load user", { cause: err }); // rethrow meaningfully
  }
}
```

## Promises — i gcónaí .catch

```js
fetchData()
  .then(process)
  .catch(err => logger.error(err)); // an unhandled rejection can crash the process
```

Is ionadh nach bhfuil `.catch` (nó try/catch timpeall `await`) i bhfianaise Promise diúltaithe — déantar **unhandled rejection** de — rud atá ina chúis go dtéann an próiseas i Node nua-aimseartha ar strus.

## An gal clasaiceach: earráidí i n-async callbacks a éalú ó try/catch

```js
// ❌ try/catch does NOT catch this — the throw happens on a LATER tick
try {
  setTimeout(() => { throw new Error("boom"); }, 100);
} catch (e) { /* never runs */ }
```

Ní thógann `try/catch` ach earráidí sa **reatha** glac comhsheasmhach. Faoin am a ritheann an timer/callback, tá an `try` bloc fada imithe. Láimhsigh an earráid *taobh istigh* an callback.

## Express async route handlers ag teastáil ar fhilleadh

```js
// ❌ a rejected async handler isn't caught by Express → request hangs
app.get("/users", async (req, res) => {
  const users = await db.getUsers(); // if this throws, Express doesn't catch it (pre-v5)
  res.json(users);
});

// ✅ wrap to forward errors to Express's error handler
const asyncH = (fn) => (req, res, next) => Promise.resolve(fn(req, res, next)).catch(next);
app.get("/users", asyncH(async (req, res) => {
  res.json(await db.getUsers()); // errors now go to next() → error middleware
}));
```

## Gréasáin dhíonúla domhanda (deireanach, ní príomh-láimhseáil)

```js
process.on("unhandledRejection", (reason) => { logger.error(reason); });
process.on("uncaughtException", (err) => { logger.error(err); process.exit(1); });
```

Is ionad feidhme iad seo chun a bheith i ngrá agus (do earráidí neamhlámhsaithe) a dhúnadh go soiléir — ní ionadh iad ar láimhseáil earráidí mar atá siad ann.

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

Is iad earráidí async gan láimhseáil a dhéantar ar bharr na liosta de chúiseanna ar thit seirbhísí Node nó ar bhris siad go i bhfolach.

An bhreacadh a bheith eolach ar na rialacha — `try/catch` timpeall `await`, i gcónaí `.catch` Promises, earráidí a láimhseáil *taobh istigh* async callbacks (ní féidir le try/catch iad a bhaint amach), agus Express async handlers a fhilleadh chun earráidí a tharchur — chuireann sé srian ar iarratais foluain, faillí folaithe, agus tuairiscí próisis.

Soláthraíonn na láimhsitheoirí domhanda gréasán deiridh, ach is é an láimhseáil ceart gach oibríochta atá ina láimhseáil Node async agus inrochtana.