Kako rokovati z napakami v asinkroni Node kodi?

Question

Accepted Answer

Rokovanje z napakami se razlikuje glede na asinkroni stil, in če ga napačno izvedete, pride do neslutenih napak ali padcev. Ključna pravila: uporabite `try/catch` z async/await, vedno rokovajte z zavrnitivami Promise-ov in nikoli ne pustite, da bi se napake v asinkronih povratnih klicev izvršile brez obravnave.

## async/await — uporabite 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 — vedno .catch

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

Zavrnitev Promise-a brez `.catch` (ali brez try/catch okrog `await`) postane **neobravnavana zavrnitev** — ki v sodobnem Node-u zaključi proces.

## Klasična past: napake v asinkronih povratnih klicev uhajajo 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` ujame samo napake v **trenutnem** sinhronem klicnem skladu. Ko se časovnik/povratni klic izvršuje, je `try` blok že dolgo potekel. Obravnavajte napako *znotraj* povratnega klica.

## Express asinkroni ruteni rukovatelji potrebujejo zavijanje

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

## Globalne varnostne mreže (zadnja možnost, ne primarno rokovanje)

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

To so varnostne mreže za beleženje in (za neobravnavane izjeme) čisto izstopanje — ne nadomestek za rokovanjem z napakami tam, kjer se pojavijo.

## Zakaj je to pomembno

Neobravnavane asinkrone napake so glavni vzrok za padce ali nesluteno pokvarjene Node storitve.

Ovladanje pravil — `try/catch` okrog `await`, vedno `.catch` Promise-ov, rokovaje s napakami *znotraj* asinkronih povratnih klicev (try/catch jih ne more dosegati) in zavijanje Express asinkronih rukovateljev za posredovanje napak — preprečuje obešene zahteve, neslutene napake in padce procesov.

Globalni rukovatelniki nudijo končno varnostno mrežo, vendar je pravilno rokovanje za vsako operacijo tisto, kar naredi asinkroni Node kod robusten in razhroščljiv.