Hur hanterar du fel i asynkron Node-kod?

Question

Accepted Answer

Felhantering skiljer sig åt beroende på asynkron stil, och att göra det fel orsakar tysta fel eller krascher. Nyckelreglerna: använd `try/catch` med async/await, hantera alltid Promise-avvisningar, och låt aldrig fel i asynkrona callbacks gå obehandlade.

## async/await — använd 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 — alltid .catch

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

En Promise-avvisning utan `.catch` (eller ingen try/catch omkring `await`) blir en **obehandlad avvisning** — vilket i modern Node avslutar processen.

## Den klassiska fällan: fel i asynkrona callbacks undgår 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` fångar endast fel i den **aktuella** synkrona anropsstacken. När timer/callback körs är `try`-blocket långt borta. Hantera felet *inuti* callback.

## Express asynkrona route-hanterare behöver omslutning

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

## Globala säkerhetsnät (sista utvägen, inte primär hantering)

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

Dessa är säkerhetsnät för att logga och (för okatchade undantag) avsluta på ett rent sätt — inte en ersättning för att hantera fel där de uppstår.

## Varför det är viktigt

Obehandlade asynkrona fel är en av de vanligaste orsakerna till kraschade eller tyst brustna Node-tjänster.

Att behärska reglerna — `try/catch` omkring `await`, alltid `.catch` Promises, hantera fel *inuti* asynkrona callbacks (try/catch kan inte nå dem), och omsluta Express asynkrona hanterare för att vidarebefordra fel — förhindrar hängande förfrågningar, tysta fel och procestkrascher.

De globala hanterarna ger ett slutligt säkerhetsnät, men korrekt hantering per operation är det som gör asynkron Node-kod robust och felsökbar.