Bagaimanakah anda menangani ralat dalam kod async Node?

Question

Accepted Answer

Penanganan ralat berbeza mengikut gaya async, dan jika salah akan menyebabkan kegagalan senyap atau ranap. Peraturan utama: gunakan `try/catch` dengan async/await, sentiasa tangani Promise rejections, dan jangan biarkan ralat dalam async callbacks terlepas tanpa ditangani.

## async/await — gunakan 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 — sentiasa .catch

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

Penolakan Promise tanpa `.catch` (atau tanpa try/catch di sekitar `await`) menjadi **unhandled rejection** — yang dalam Node moden menghentikan proses.

## Perangkap klasik: ralat dalam 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` hanya menangani ralat dalam **current** synchronous call stack. Apabila timer/callback berjalan, blok `try` sudah hilang. Tangani ralat *di dalam* callback.

## Express async route handlers memerlukan pembungkusan

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

## Jaring keselamatan global (jalan terakhir, bukan penanganan utama)

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

Ini adalah jaring keselamatan untuk log dan (untuk pengecualian yang tidak ditangani) keluar dengan bersih — bukan pengganti untuk menangani ralat tempat mereka berlaku.

## Mengapa penting

Ralat async yang tidak ditangani adalah salah satu penyebab utama perkhidmatan Node yang ranap atau gagal senyap.

Menguasai peraturan — `try/catch` di sekeliling `await`, sentiasa `.catch` Promises, tangani ralat *di dalam* async callbacks (try/catch tidak boleh menjangkau mereka), dan bungkus async route handlers Express untuk meneruskan ralat — mencegah permintaan tertunda, kegagalan senyap, dan ranap proses.

Penanganan global memberikan jaring keselamatan akhir, tetapi penanganan per-operasi yang betul adalah yang menjadikan kod async Node robust dan mudah di-debug.