Wie gehen Sie mit Fehlern in async Node-Code um?

Question

Accepted Answer

Die Fehlerbehandlung unterscheidet sich je nach async-Stil, und Fehler führen zu stillen Ausfällen oder Abstürzen. Die Schlüsselregeln: Verwenden Sie `try/catch` mit async/await, behandeln Sie immer Promise-Rejections und lassen Sie Fehler in async-Callbacks nicht unbehandelt entkommen.

## async/await — verwenden Sie 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 — immer .catch

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

Eine Promise-Rejection ohne `.catch` (oder ohne try/catch um `await`) wird zu einer **unbehandelten Rejection** — was in modernem Node den Prozess beendet.

## Die klassische Falle: Fehler in async-Callbacks entgehen 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ängt nur Fehler im **aktuellen** synchronen call stack. Wenn der Timer/Callback läuft, ist der `try`-Block längst vorbei. Behandeln Sie den Fehler *innerhalb* des Callbacks.

## Express async route handler benötigen Wrapping

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

## Warum es wichtig ist

Unbehandelte async-Fehler sind eine der Hauptursachen für abgestürzte oder still fehlgeschlagene Node-Services.

Die Beherrschung der Regeln — `try/catch` um `await`, immer `.catch` für Promises, Fehler *innerhalb* von async-Callbacks behandeln (try/catch kann sie nicht erreichen), und Express async-Handler zum Weiterleiten von Fehlern wrappen — verhindert hängende Requests, stille Fehler und Prozessabstürze.

Die globalen Handler bieten ein letztes Sicherheitsnetz, aber korrekte Fehlerbehandlung pro Operation ist das, was async Node-Code robust und debuggbar macht.

## Globale Sicherheitsnetze (letzter Ausweg, nicht primäre Behandlung)

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

Dies sind Sicherheitsnetze zum Protokollieren und (bei unbehandelten Ausnahmen) zum sauberen Beenden — kein Ersatz für die Fehlerbehandlung dort, wo sie auftritt.