Kepiye carane nangani errors ing kode async Node?

Question

IT Interview Practice · Accepted Answer

Error handling beda-beda miturut gaya async, lan yen salah bakal nyebabake silent failures utawa crashes. Aturan utama: gunakake `try/catch` karo async/await, tansah nangani Promise rejections, lan aja nganti errors ing async callbacks lolos ora ditangani.

## async/await — gunakake 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 — tansah .catch

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

A Promise rejection tanpa `.catch` (utawa tanpa try/catch ing `await`) dadi **unhandled rejection** — sing ing Node modern bisa mutusake proses.

## Jebakan klasik: errors ing async callbacks lolos 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 */ }
```

`try/catch` mung nangani errors ing **current** synchronous call stack. Nalika timer/callback dijalanake, `try` block wis ilang. Nangani error *ing jero* callback.

## Express async route handlers kudu dibalut

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

## Global safety nets (cara terakhir, dudu primary handling)

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

Ini minangka safety nets kanggo nglog lan (kanggo uncaught exceptions) metu kanthi bersih — dudu pengganti kanggo nangani errors ing jero.

## Apa gunane

Unhandled async errors minangka salah siji penyebab utama Node services sing rusak utawa silent-broken.

Menguasai aturan — `try/catch` ing seliwa `await`, tansah `.catch` Promises, nangani errors *ing jero* async callbacks (try/catch ora bisa ngraihi), lan balut Express async handlers kanggo forward errors — nyegah hanging requests, silent failures, lan process crashes.

Global handlers nyedhiyakake safety net final, nanging correct per-operation handling sing nggawe async Node code robust lan debuggable.

async/await — gunakake try/catch

Promises — tansah .catch

Jebakan klasik: errors ing async callbacks lolos try/catch

Express async route handlers kudu dibalut

Global safety nets (cara terakhir, dudu primary handling)

Apa gunane

Pitakon sing gegandhengan