webentwicklung-frage-antwort-db.com.de

Wie kann ich 404-Fehler auf eine Seite in ExpressJS umleiten?

Ich kenne keine Funktion dafür, kennt jemand eine?

182
Julio García

Ich fand dieses Beispiel sehr hilfreich:

https://github.com/visionmedia/express/blob/master/examples/error-pages/index.js

So ist es eigentlich dieser Teil:

// "app.router" positions our routes
// above the middleware defined below,
// this means that Express will attempt
// to match & call routes _before_ continuing
// on, at which point we assume it's a 404 because
// no route has handled the request.

app.use(app.router);

// Since this is the last non-error-handling
// middleware use()d, we assume 404, as nothing else
// responded.

// $ curl http://localhost:3000/notfound
// $ curl http://localhost:3000/notfound -H "Accept: application/json"
// $ curl http://localhost:3000/notfound -H "Accept: text/plain"

app.use(function(req, res, next){
  res.status(404);

  // respond with html page
  if (req.accepts('html')) {
    res.render('404', { url: req.url });
    return;
  }

  // respond with json
  if (req.accepts('json')) {
    res.send({ error: 'Not found' });
    return;
  }

  // default to plain-text. send()
  res.type('txt').send('Not found');
});
251
Felix

Ich denke du solltest zuerst alle deine Routen definieren und als letzte Route hinzufügen

//The 404 Route (ALWAYS Keep this as the last route)
app.get('*', function(req, res){
  res.status(404).send('what???');
});

Eine Beispiel-App, die funktioniert:

app.js:

var express = require('express'),
    app = express.createServer();

app.use(express.static(__dirname + '/public'));

app.get('/', function(req, res){
  res.send('hello world');
});

//The 404 Route (ALWAYS Keep this as the last route)
app.get('*', function(req, res){
  res.send('what???', 404);
});

app.listen(3000, '127.0.0.1');

[email protected]:~/node/stackoverflow/6528876$ mkdir public
[email protected]:~/node/stackoverflow/6528876$ find .
[email protected]:~/node/stackoverflow/6528876$ echo "I don't find a function for that... Anyone knows?" > public/README.txt
[email protected]:~/node/stackoverflow/6528876$ cat public/README.txt 

.
./app.js
./public
./public/README.txt

[email protected]:~/node/stackoverflow/6528876$ curl http://localhost:3000/
hello world
[email protected]:~/node/stackoverflow/6528876$ curl http://localhost:3000/README.txt
I don't find a function for that... Anyone knows?
130
Alfred

Sie können eine Middleware an die letzte Position setzen, die einen NotFound-Fehler auslöst.
oder stellt sogar die 404-Seite direkt dar:

app.use(function(req,res){
    res.status(404).render('404.jade');
});
31
Ganesh Kumar

Die obigen Antworten sind gut, aber in der Hälfte dieser Fälle werden keine 404-Werte angezeigt, da Ihr HTTP-Statuscode zurückgegeben wird, und in der anderen Hälfte können Sie keine benutzerdefinierte Vorlage rendern. Der beste Weg, eine benutzerdefinierte Fehlerseite (404) in Expressjs zu haben, ist

app.use(function(req, res, next){
    res.status(404).render('404_error_template', {title: "Sorry, page not found"});
});

Fügen Sie diesen Code am Ende aller URL-Zuordnungen ein.

31
Sushant Gupta

Die Antwort auf Ihre Frage lautet:

app.use(function(req, res) {
    res.status(404).end('error');
});

Und es gibt einen großartigen Artikel darüber, warum es der beste Weg ist hier .

4
Marius Cotofana

In der letzten Zeile von app.js setzen Sie einfach diese Funktion. Dadurch wird die Standardfehlerseite für nicht gefundene Seite überschrieben:

app.use(function (req, res) {
    res.status(404).render('error');
});

Es werden alle Anforderungen überschrieben, die keinen gültigen Handler haben, und Ihre eigene Fehlerseite wird gerendert.

4
Vivek Bajpai

Es gibt einige Fälle, in denen die 404-Seite nicht als letzte Route ausgeführt werden kann, insbesondere wenn Sie über eine asynchrone Routing-Funktion verfügen, die eine/route zu spät zum Teilnehmer bringt. Das Muster unten könnte in diesen Fällen übernommen werden. 

var express = require("express.io"),
    app = express(),
    router = express.Router();

router.get("/hello", function (req, res) {
    res.send("Hello World");
});

// Router is up here.
app.use(router);

app.use(function(req, res) {
    res.send("Crime Scene 404. Do not repeat");
});

router.get("/late", function (req, res) {
    res.send("Its OK to come late");
});

app.listen(8080, function (){
    console.log("Ready");
});
3
Lalith

Mit express-error-handler können Sie benutzerdefinierte Vorlagen, statische Seiten oder Fehlerbehandlungsroutinen für Ihre Fehler angeben. Darüber hinaus werden weitere nützliche Fehlerbehandlungsaufgaben ausgeführt, die jede App implementieren sollte, z. B. Schutz vor DOS-Angriffen mit 4xx-Fehlern und ein ordnungsgemäßes Herunterfahren bei nicht behebbaren Fehlern. So tun Sie, wonach Sie fragen:

var errorHandler = require('express-error-handler'),
  handler = errorHandler({
    static: {
      '404': 'path/to/static/404.html'
    }
  });

// After all your routes...
// Pass a 404 into next(err)
app.use( errorHandler.httpError(404) );

// Handle all unhandled errors:
app.use( handler );

Oder für einen benutzerdefinierten Handler:

handler = errorHandler({
  handlers: {
    '404': function err404() {
      // do some custom thing here...
    }
  }
}); 

Oder für eine benutzerdefinierte Ansicht:

handler = errorHandler({
  views: {
    '404': '404.jade'
  }
});
3
Eric Elliott
// Add this middleware
// error handler
app.use(function(err, req, res, next) {
 // set locals, only providing error in development
   res.locals.message = err.message;
   res.locals.error = req.app.get('env') === 'development' ? err : {};

 // render the error page
   res.status(err.status || 500);
   res.render('error');
  });
2
ASHISH RANJAN

Hallo, bitte finde die Antwort

const express = require('express');
const app = express();
const port = 8080;

app.get('/', (req, res) => res.send('Hello home!'));
app.get('/about-us', (req, res) => res.send('Hello about us!'));
app.post('/user/set-profile', (req, res) => res.send('Hello profile!'));
//last 404 page 
app.get('*', (req, res) => res.send('Page Not found 404'));
app.listen(port, () => console.log(`Example app listening on port ${port}!`));

sie können Fehlerbehandlung je nach Inhaltstyp durchführen 

Zusätzlich Handhabung gemäß Statuscode.

app.js

import express from 'express';

// catch 404 and forward to error handler
app.use(function(req, res, next) {
  var err = new Error('Not Found');
  err.status = 404;
  next(err);
});

// when status is 404, error handler
app.use(function(err, req, res, next) {
    // set locals, only providing error in development
    res.locals.message = err.message;
    res.locals.error = req.app.get('env') === 'development' ? err : {};

    // render the error page
    res.status(err.status || 500);
    if( 404 === err.status  ){
        res.format({
            'text/plain': () => {
                res.send({message: 'not found Data'});
            },
            'text/html': () => {
                res.render('404.jade');
            },
            'application/json': () => {
                res.send({message: 'not found Data'});
            },
            'default': () => {
                res.status(406).send('Not Acceptable');
            }
        })
    }

    // when status is 500, error handler
    if(500 === err.status) {
        return res.send({message: 'error occur'});
    }
});

404.jade

doctype html

html
  head
    title 404 Not Found

    meta(http-equiv="Content-Type" content="text/html; charset=utf-8")
    meta(name = "viewport" content="width=device-width, initial-scale=1.0 user-scalable=no")

  body
      h2 Not Found Page
      h2 404 Error Code

Wenn Sie das res.format verwenden können, können Sie einfachen Fehlerbehandlungscode schreiben.

Empfehlung res.format() statt res.accepts().

Wenn der 500-Fehler im vorherigen Code auftritt, wird if(500 == err.status){. . . } aufgerufen 

1
멍개-mung

Obwohl die obigen Antworten richtig sind, müssen Sie für diejenigen, die dies in IISNODE zum Laufen bringen wollen, auch angeben 

<configuration>
    <system.webServer>
        <httpErrors existingResponse="PassThrough"/>
    </system.webServer>
<configuration>

in Ihrer web.config (andernfalls frisst IIS Ihre Ausgabe).

1
laktak

Der einfachste Weg, dies zu tun, besteht darin, alles auf Fehler zu setzen

// Step 1: calling express
const express = require("express");
const app = express();

Dann

// require Path to get file locations
const path = require("path");

Jetzt können Sie alle Ihre "HTML" -Seiten (einschließlich einer Fehlerseite "HTML") in einer Variablen speichern

// Storing file locations in a variable
var indexPg = path.join(__dirname, "./htmlPages/index.html");
var aboutPg = path.join(__dirname, "./htmlPages/about.html");
var contactPg = path.join(__dirname, "./htmlPages/contact.html");
var errorPg = path.join(__dirname, "./htmlPages/404.html"); //this is your error page

Jetzt rufen Sie die Seiten einfach mit der Get-Methode auf und haben alle Optionen, die nicht zur Verfügung stehen, um mit App.get ("*") zu Ihrer Fehlerseite zu gelangen.

//Step 2: Defining Routes
//default page will be your index.html
app.get("/", function(req,res){
  res.sendFile(indexPg);
});
//about page
app.get("/about", function(req,res){
  res.sendFile(aboutPg);
});
//contact page
app.get("/contact", function(req,res){
  res.sendFile(contactPg);
});
//catch all endpoint will be Error Page
app.get("*", function(req,res){
  res.sendFile(errorPg);
});

Vergessen Sie nicht, einen Port einzurichten und auf Server zu warten:

// Setting port to listen on
const port = process.env.PORT || 8000;
// Listening on port
app.listen(port, function(){
  console.log(`http://localhost:${port}`);
})

Jetzt sollte Ihre Fehlerseite für alle nicht erkannten Endpunkte angezeigt werden!

0
Kean Amaral

Ich habe den folgenden Handler verwendet, um 404-Fehler mit einer statischen .ejs-Datei zu behandeln.

Setzen Sie diesen Code in ein Routenskript und fordern Sie dann file.js durch app.use() in Ihrem app.js/server.js/www.js an (wenn Sie IntelliJ für NodeJS verwenden)

Sie können auch eine statische .html-Datei verwenden.

//Unknown route handler
 router.get("[otherRoute]", function(request, response) {
     response.status(404);
     response.render("error404.[ejs]/[html]");
     response.end();
 });

Auf diese Weise antwortet der Express-Server mit einem korrekten 404 error und Ihre Website kann auch eine Seite enthalten, auf der die Antwort des Servers 404 korrekt angezeigt wird. Sie können auch eine navbar in diesen 404 error template einfügen, die auf andere wichtige Inhalte Ihrer Website verweist.

0
mudrak patel

Wenn Sie ein Express-Generator-Paket verwenden: 

next (err);

Dieser Code sendet Sie an die 404-Middleware.

0
Josué Díaz

So senden Sie eine benutzerdefinierte Seite:

app.get('*', function(req, res){
  if (req.accepts('html')) {
     res.send('404', '<script>location.href = "/the-404-page.html";</script>');
     return;
  }
});
0
Kristian

Wenn Sie von Ihren Funktionen (Routen) zu Fehlerseiten umleiten möchten, gehen Sie wie folgt vor: 

  1. Fügen Sie allgemeinen Fehlermeldungen in Ihre app.js ein -

    app.use(function(err, req, res, next) {
        // set locals, only providing error in development
        res.locals.message = err.message
        res.locals.error = req.app.get('env') === 'development' ? err : {}
    
        // render the error page
        // you can also serve different error pages
        // for example sake, I am just responding with simple error messages 
        res.status(err.status || 500)
       if(err.status === 403){
           return res.send('Action forbidden!');
       }
    
       if(err.status === 404){
           return res.send('Page not found!');
       }
    
       // when status is 500, error handler
       if(err.status === 500) {
           return res.send('Server error occured!');
       }
       res.render('error')
    })
    
  2. Anstelle einer Fehlerseitenumleitung können Sie in Ihrer Funktion zunächst den Fehlerstatus festlegen und dann next () verwenden, damit der Code-Fluss den obigen Code durchläuft

    if(FOUND){
        ...
    }else{
        // redirecting to general error page
        // any error code can be used (provided you have handled its error response)
        res.status(404)
        // calling next() will make the control to go call the step 1. error code
        // it will return the error response according to the error code given (provided you have handled its error response)
        next()
    }
    
0
Anshul Bisht