Kaip tvarkote klaidas async Node kode?

Question

Accepted Answer

Klaidų tvarkymas skiriasi priklausomai nuo async stiliaus, ir jei padarytė neteisingai, tai sukelia tylias žlugimas arba strigtis. Pagrindinės taisyklės: naudokite `try/catch` su async/await, visada tvarkykite Promise atmetimus, ir niekada neleiskite klaidoms async callback'uose likti netvarkytos.

## async/await — naudokite 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 — visada .catch

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

Promise atmetimas be `.catch` (arba be try/catch aplink `await`) tampa **netvarkyta atmestyje** — kuri šiuolaikiniame Node nutraukia procesą.

## Klasikinis spąstai: klaidos async callback'uose pabėga iš 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` tik išlavina klaidas **dabartiniame** sinchroniniame call stack'e. Kai timer/callback paleistas, `try` blokas jau išnyksta. Tvarkykite klaidą *callback'o viduje*.

## Express async maršrutų tvarkytuvams reikalingas apvijimas

```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ūs saugos tinklai (paskutinis pasiklymas, ne pirminis tvarkos būdas)

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

Tai saugos tinklai, skirti žurnalizuoti ir (netvarkytų išimčių atveju) švariai baigti — ne klaidų tvarkymo pakaitalas ten, kur jie atsiranda.

## Kodėl tai svarbu

Netvarkyta async klaidos yra vienas iš pagrindinių Node paslaugų sutrūkimo arba tylaus sugedimo priežasčių.

Išmokus taisykles — `try/catch` aplink `await`, visada `.catch` Promises, tvarkykite klaidas *async callback'ų viduje* (try/catch negali jų pasiekti), ir apvijite Express async tvarkytuvus klaidoms persiųsti — užkertate kelią kabliojusiems užklausoms, tyliem žlugimams ir proceso sutrūkimams.

Globalūs tvarkytuvai suteikia galutinį saugumo tinklą, bet taisyklingas per-operacinis tvarkos būdas yra tai, kas daro async Node kodą tvirtą ir derinamu.