Diese ├ťbersetzung zur Verf├╝gung gestellt von StrongLoop / IBM.

Dieses Dokument kann im Vergleich zur englischen Dokumentation veraltet sein. Aktuelle Updates finden Sie in der englischen Dokumentation.

Ôťľ

Fehlerbehandlung

Middlewarefunktionen f├╝r die Fehlerbehandlung werden in derselben Weise definiert wie andere Middlewarefunktionen, nur, dass Fehlerbehandlungsfunktionen vier anstatt drei Argumente aufweisen: (err, req, res, next). Beispiel:


app.use(function(err, req, res, next) {
  console.error(err.stack);
  res.status(500).send('Something broke!');
});

Middleware f├╝r die Fehlerbehandlung wird ganz zuletzt nach allen anderen app.use()- und Weiterleitungsaufrufen definiert. Beispiel:


var bodyParser = require('body-parser');
var methodOverride = require('method-override');

app.use(bodyParser());
app.use(methodOverride());
app.use(function(err, req, res, next) {
  // logic
});

Antworten von der Middlewarefunktion k├Ânnen das von Ihnen gew├╝nschte Format aufweisen wie beispielsweise eine Fehlerseite im HTML-Format, eine einfache Nachricht oder eine JSON-Zeichenfolge.

F├╝r organisatorische Zwecke (und Frameworks der h├Âheren Ebene) k├Ânnen Sie mehrere Middlewarefunktionen f├╝r die Fehlerbehandlung definieren, wie Sie dies bei regul├Ąren Middlewarefunktionen auch tun w├╝rden. Wenn Sie beispielsweise eine Fehlerbehandlungsroutine (Error-Handler) f├╝r Anforderungen ├╝ber XHR und andere Anforderungen definieren wollen, k├Ânnen Sie die folgenden Befehle verwenden:


var bodyParser = require('body-parser');
var methodOverride = require('method-override');

app.use(bodyParser());
app.use(methodOverride());
app.use(logErrors);
app.use(clientErrorHandler);
app.use(errorHandler);

In diesem Beispiel kann die generische logErrors-Funktion Anforderungs- und Fehlerinformationen in stderr schreiben:


function logErrors(err, req, res, next) {
  console.error(err.stack);
  next(err);
}

In diesem Beispiel wird clientErrorHandler wie folgt definiert. In diesem Fall wird der Fehler explizit an den n├Ąchsten Error-Handler ├╝bergeben:


function clientErrorHandler(err, req, res, next) {
  if (req.xhr) {
    res.status(500).send({ error: 'Something failed!' });
  } else {
    next(err);
  }
}

Die errorHandler-Funktion ÔÇťcatch-allÔÇŁ kann wie folgt implementiert werden:


function errorHandler(err, req, res, next) {
  res.status(500);
  res.render('error', { error: err });
}

Wenn Sie ├ťbergaben an die Funktion next() vornehmen (au├čer die Zeichenfolge 'route'), sieht Express die aktuelle Anforderung als Fehler an und ├╝berspringt alle verbleibenden fehlerfreien Behandlungsroutinen und Middlewarefunktionen. Wenn Sie den Fehler bearbeiten wollen, m├╝ssen Sie (wie im n├Ąchsten Abschnitt beschrieben) eine Fehlerbehandlungsweiterleitung erstellen.

Bei einem Routenhandler mit mehreren Callback-Funktionen k├Ânnen Sie den Parameter route verwenden, um den n├Ąchsten Routenhandler zu ├╝berspringen. Beispiel:


app.get('/a_route_behind_paywall',
  function checkIfPaidSubscriber(req, res, next) {
    if(!req.user.hasPaid) {

      // continue handling this request
      next('route');
    }
  }, function getPaidContent(req, res, next) {
    PaidContent.find(function(err, doc) {
      if(err) return next(err);
      res.json(doc);
    });
  });

In diesem Beispiel wird der Handler getPaidContent ├╝bersprungen. Alle verbleibenden Handler in app f├╝r /a_route_behind_paywall werden jedoch weiter ausgef├╝hrt.

Aufrufe zu next() und next(err) geben an, dass der aktuelle Handler abgeschlossen ist und welchen Status er aufweist. Durch next(err) werden alle verbleibenden Handler in der Kette ├╝bersprungen. Ausgenommen hiervor sind die Handler, die konfiguriert sind, um Fehler wie oben beschrieben zu behandeln.

Die Standardfehlerbehandlungsroutine (Default Error Handler)

Express ist bereits mit einer integrierten Fehlerbehandlungsroutine ausgestattet, mit der alle in der Anwendung festgestellten Fehler gehandhabt werden k├Ânnen. Diese Middleware f├╝r die Fehlerbehandlung wird am Ende des Middleware-Funktionsstack hinzugef├╝gt.

Wenn Sie einen Fehler an next() ├╝bergeben und diesen nicht mit einem Error-Handler bearbeiten, wird dieser ├╝ber den integrierten Error-Handler bearbeitet. Der Fehler wird mit dem Stack-Trace zum Client geschrieben. Der Stack-Trace ist in der Produktionsumgebung nicht verf├╝gbar.

Legen Sie die Umgebungsvariable NODE_ENV auf production fest, um die Anwendung im Produktionsmodus auszuf├╝hren.

Wenn next() mit einem Fehler aufgerufen wird, nachdem Sie mit dem Schreiben der Antwort begonnen haben (z. B., wenn Sie beim Streamen der Antwort zum Client einen Fehler feststellen), schlie├čt die Standardfehlerbehandlungsroutine in Express die Verbindung, und die Anforderung schl├Ągt fehl.

Wenn Sie also einen angepassten Error-Handler hinzuf├╝gen, empfiehlt es sich, eine Delegierung zur Standardfehlerbehandlungsroutine in Express vorzunehmen, wenn die Header bereits an den Client gesendet wurden:


function errorHandler(err, req, res, next) {
  if (res.headersSent) {
    return next(err);
  }
  res.status(500);
  res.render('error', { error: err });
}