Der Umgang mit Fehlern in Node.js besteht im Allgemeinen aus dem Erkennen und Reagieren auf diese Fehler. Es gibt mehrere Arten von Fehlern im Zusammenhang mit Node.js, einschließlich Standard-JavaScript-Fehlern, systembezogenen Fehlern und vom Benutzer definierten Fehlern.
1. Fehlererkennung: Die `try…catch`-Struktur ermöglicht die Erkennung von synchronen Fehlern. Async-Fehler können über die `callback`-Funktion oder Promise-`rejects` erkannt werden.
Beispiel:
```javascript
try {
// some code here
} catch (error) {
console.error(error);
}
```
2. Fehlerbehandlung: Mit der `next`-Funktion in Express können Sie Fehler an die nächste Middleware-Funktion in der Kette weitergeben.
Beispiel:
```javascript
app.get(‘/’, function (req, res, next) {
fs.readFile(‘/file-does-not-exist’, function (err, data) {
if (err) {
next(err) // Pass errors to Express.
} else {
res.send(data)
}
})
})
```
3. Fehlerprotokollierung: Es wird empfohlen, ein Protokollierungsmodul wie `winston` oder `bunyan` zu verwenden, um Fehlerprotokolle zu erstellen und Informationen aufzuzeichnen.
4. Fehlerantworten: Bei der Gestaltung der API sollte es klare Richtlinien geben, wie auf verschiedene Arten von Fehlern reagiert wird. Im Allgemeinen sollte ein HTTP-Statuscode gesendet werden, der den Zustand der Anforderung widerspiegelt, zusammen mit einer Nachricht, die den Fehler im Detail beschreibt.
5. Unbehandelte Ausnahmen und Versprechen: Für unbehandelte Ausnahmen und abgelehnte Versprechen sollten `uncaughtException` und `unhandledRejection` Events verwendet werden.
```javascript
process.on(‘uncaughtException’, (err, origin) => {
console.error(`Caught exception: ${err}\n` +
`Exception origin: ${origin}`);
});
process.on(‘unhandledRejection’, (reason, promise) => {
console.error(‘Unhandled Rejection at:’, promise, ‘reason:’, reason);
// Application specific logging, throwing an error, or other logic here
});
```
Darüber hinaus ist es sinnvoll, Tests zu schreiben, um sicherzustellen, dass Ihr Code bei Fehlern angemessen reagiert, und sich zudem mit zuverlässigen Fehlerüberwachungssystemen zu befassen.
