Xử lý lỗi trong code bất đồng bộ của Node như thế nào?

Question

Accepted Answer

Xử lý lỗi khác nhau theo kiểu bất đồng bộ, và làm sai gây ra thất bại âm thầm hoặc crash. Các quy tắc chính: dùng `try/catch` với async/await, luôn xử lý Promise bị reject, và không bao giờ để lỗi trong callback bất đồng bộ thoát ra mà không bắt.

## async/await — dùng try/catch

```js
async function getUser(id) {
  try {
    const user = await db.findUser(id);   // một reject ở đây ném vào catch
    return user;
  } catch (err) {
    logger.error(err);
    throw new AppError("Không tải được user", { cause: err }); // ném lại có ý nghĩa
  }
}
```

## Promise — luôn .catch

```js
fetchData()
  .then(process)
  .catch(err => logger.error(err)); // một reject chưa xử lý có thể crash tiến trình
```

Một Promise bị reject không có `.catch` (hoặc không try/catch quanh `await`) trở thành **unhandled rejection** — trong Node hiện đại sẽ kết thúc tiến trình.

## Cái bẫy kinh điển: lỗi trong callback bất đồng bộ thoát khỏi try/catch

```js
// ❌ try/catch KHÔNG bắt được — lệnh throw xảy ra ở một tick SAU
try {
  setTimeout(() => { throw new Error("boom"); }, 100);
} catch (e) { /* không bao giờ chạy */ }
```

`try/catch` chỉ bắt lỗi trong ngăn xếp gọi đồng bộ **hiện tại**. Đến khi timer/callback chạy, khối `try` đã qua từ lâu. Hãy xử lý lỗi *bên trong* callback.

## Route handler bất đồng bộ của Express cần được bọc

```js
// ❌ một handler async bị reject không được Express bắt → request treo
app.get("/users", async (req, res) => {
  const users = await db.getUsers(); // nếu ném lỗi, Express không bắt (trước v5)
  res.json(users);
});

// ✅ bọc để chuyển lỗi tới error handler của Express
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()); // lỗi giờ đi tới next() → error middleware
}));
```

## Lưới an toàn toàn cục (cuối cùng, không phải xử lý chính)

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

Đây là lưới an toàn để ghi log và (với ngoại lệ chưa bắt) thoát sạch — không thay thế việc xử lý lỗi ngay nơi nó xảy ra.

## Tại sao điều này quan trọng

Lỗi bất đồng bộ chưa xử lý là một nguyên nhân hàng đầu khiến service Node crash hoặc hỏng âm thầm.

Nắm vững các quy tắc — `try/catch` quanh `await`, luôn `.catch` Promise, xử lý lỗi *bên trong* callback bất đồng bộ (try/catch không với tới được), và bọc handler async của Express để chuyển lỗi — ngăn request treo, thất bại âm thầm và crash tiến trình.

Các handler toàn cục cung cấp lưới an toàn cuối cùng, nhưng xử lý đúng từng thao tác mới làm code bất đồng bộ của Node vững chắc và dễ debug.