คุณจัดการ error ในโค้ด async ของ Node อย่างไร?

Question

Accepted Answer

การจัดการ error แตกต่างกันตามสไตล์ async และการทำผิดทำให้เกิดความล้มเหลวแบบเงียบ ๆ หรือ crash กฎสำคัญคือ ใช้ `try/catch` กับ async/await, จัดการ Promise rejection เสมอ และอย่าปล่อยให้ error ใน async callback หลุดออกไปโดยไม่ถูกจัดการ

## async/await — ใช้ 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 — ใช้ .catch เสมอ

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

Promise rejection ที่ไม่มี `.catch` (หรือไม่มี try/catch รอบ `await`) จะกลายเป็น **unhandled rejection** — ซึ่งใน Node สมัยใหม่จะทำให้ process ปิดตัวลง

## กับดักคลาสสิก: error ใน async callback หลุดออกจาก 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` จับได้เฉพาะ error ใน call stack แบบ synchronous **ปัจจุบัน** เท่านั้น เมื่อ timer/callback ทำงาน บล็อก `try` ได้ผ่านพ้นไปนานแล้ว ให้จัดการ error *ภายใน* callback แทน

## Express async route handler ต้องถูกห่อ

```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 (ทางเลือกสุดท้าย ไม่ใช่การจัดการหลัก)

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

สิ่งเหล่านี้เป็นตาข่ายความปลอดภัยไว้ log และ (สำหรับ uncaught exception) ปิดตัวอย่างเรียบร้อย — ไม่ใช่สิ่งทดแทนการจัดการ error ตรงจุดที่มันเกิดขึ้น

## ทำไมจึงสำคัญ

Error แบบ async ที่ไม่ถูกจัดการเป็นสาเหตุอันดับต้น ๆ ของ Node service ที่ crash หรือพังแบบเงียบ ๆ

การเชี่ยวชาญกฎเหล่านี้ — `try/catch` รอบ `await`, ใช้ `.catch` กับ Promise เสมอ, จัดการ error *ภายใน* async callback (try/catch เข้าไม่ถึง) และห่อ Express async handler เพื่อส่งต่อ error — ป้องกัน request ที่ค้าง, ความล้มเหลวแบบเงียบ และ process crash

Global handler เป็นตาข่ายความปลอดภัยสุดท้าย แต่การจัดการที่ถูกต้องในแต่ละ operation ต่างหากที่ทำให้โค้ด async ของ Node แข็งแรงและ debug ได้