Come reindirizzare gli errori 404 a una pagina in ExpressJS?

Non conosco una funzione per farlo, qualcuno ne conosce una?

Ho trovato questo esempio abbastanza utile:

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

Quindi in realtà è questa parte:

// "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');
});

Penso che dovresti prima definire tutti i tuoi percorsi e come aggiungere l'ultimo percorso

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

Un'app di esempio che funziona:

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');

alfred@alfred-laptop:~/node/stackoverflow/6528876$ mkdir public
alfred@alfred-laptop:~/node/stackoverflow/6528876$ find .
alfred@alfred-laptop:~/node/stackoverflow/6528876$ echo "I don't find a function for that... Anyone knows?" > public/README.txt
alfred@alfred-laptop:~/node/stackoverflow/6528876$ cat public/README.txt 

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

alfred@alfred-laptop:~/node/stackoverflow/6528876$ curl http://localhost:3000/
hello world
alfred@alfred-laptop:~/node/stackoverflow/6528876$ curl http://localhost:3000/README.txt
I don't find a function for that... Anyone knows?

È possibile inserire un middleware nell'ultima posizione che genera un NotFounderrore
o addirittura visualizzare direttamente la pagina 404:

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

Le risposte di cui sopra sono buone, ma nella metà di queste non otterrai 404 come il tuo codice di stato HTTP restituito e nella seconda metà non sarai in grado di avere un rendering del modello personalizzato. Il modo migliore per avere una pagina di errore personalizzata (404) in Expressjs è

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

Inserisci questo codice alla fine di tutti i tuoi mapping URL.

All'ultima riga di app.js inserisci questa funzione. Questo sostituirà la pagina di errore predefinita non trovata:

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

Sovrascriverà tutte le richieste che non hanno un gestore valido e visualizzerà la tua pagina di errore.

La risposta alla tua domanda è:

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

E c'è un ottimo articolo sul perché è il modo migliore qui .

express-error-handler ti consente di specificare modelli personalizzati, pagine statiche o gestori di errori per i tuoi errori. Fa anche altre cose utili per la gestione degli errori che ogni app dovrebbe implementare, come la protezione dagli attacchi DOS con errore 4xx e l'arresto gradevole degli errori irrecuperabili. Ecco come fai quello che stai chiedendo:

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

O per un gestore personalizzato:

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

O per una vista personalizzata:

handler = errorHandler({
  views: {
    '404': '404.jade'
  }
});

Ci sono alcuni casi in cui la pagina 404 non può essere scritta per essere eseguita come ultima route, specialmente se si dispone di una funzione di routing asincrona che porta in / route in ritardo alla parte. Il modello seguente potrebbe essere adottato in questi casi.

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

https://github.com/robrighter/node-boilerplate/blob/master/templates/app/server.js

Questo è ciò che fa il nodo-boilerplate.

// 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');
  });

Il modo più semplice per farlo è di catturare tutto per la pagina di errore

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

Poi

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

Ora puoi memorizzare tutte le tue pagine "html" (inclusa una pagina "html" di errore) in una variabile

// 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

Ora chiami semplicemente le pagine usando il metodo Get e hai un fermo tutto per tutti i percorsi non disponibili per indirizzare alla tua pagina di errore utilizzando app.get ("*")

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

Non dimenticare di impostare una porta e ascoltare il server:

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

Questo dovrebbe ora mostrare la tua pagina di errore per tutti gli endpoint non riconosciuti!

Mentre le risposte sopra sono corrette, per coloro che vogliono farlo funzionare in IISNODE devi anche specificare

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

nel tuo web.config (altrimenti IIS mangerà il tuo output).

puoi gestire gli errori in base al tipo di contenuto

Inoltre, la gestione in base al codice di stato.

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

Se è possibile utilizzare res.format, è possibile scrivere un semplice codice di gestione degli errori.

Raccomandazione res.format()anzichéres.accepts() .

Se l'errore 500 si verifica nel codice precedente, if(500 == err.status){. . . }viene chiamato

Ciao, per favore, trova la risposta

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

Se si utilizza il pacchetto express-generator:

successivo (err);

Questo codice ti invia al middleware 404.

Per inviare a una pagina personalizzata:

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

Ho usato il gestore di seguito per gestire l'errore 404 con un .ejsfile statico .

Inserire questo codice in uno script di route e quindi richiederlo file.jstramite app.use()in app.js/ server.js/ www.js(se si utilizza IntelliJ per NodeJS)

Puoi anche usare un .htmlfile statico .

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

In questo modo, il server espresso in esecuzione risponderà con una corretta 404 errore il tuo sito Web può anche includere una pagina che visualizza correttamente la risposta 404 del server. Puoi anche includere un navbarin che 404 error templaterimanda ad altri contenuti importanti del tuo sito web.

Se desideri reindirizzare a pagine di errore dalle tue funzioni (rotte), procedi come segue:

1. Aggiungi il codice dei messaggi di errore generali nel tuo app.js -

   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. Nella tua funzione, invece di utilizzare un reindirizzamento della pagina di errore, puoi utilizzare prima impostare lo stato dell'errore e quindi utilizzare next () affinché il flusso di codice passi attraverso il codice sopra -

   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()
   }

La pagina 404 deve essere configurata poco prima della chiamata a app.listen.Express ha il supporto per * nei percorsi di instradamento. Questo è un personaggio speciale che si adatta a qualsiasi cosa. Questo può essere usato per creare un gestore di route che corrisponda a tutte le richieste.

app.get('*', (req, res) => {
  res.render('404', {
    title: '404',
    name: 'test',
    errorMessage: 'Page not found.'
  })
})

Copertura di tutti i verbi HTTP in express

Per coprire tutti i verbi HTTP e tutti i percorsi rimanenti è possibile utilizzare:

app.all('*', cb)

La soluzione finale sembrerebbe così:

app.all('*', (req, res) =>{
    res.status(404).json({
        success: false,
        data: '404'
    })
})

Non dovresti dimenticare di mettere il router alla fine. Perché l'ordine dei router è importante.

Il codice sopra non ha funzionato per me.

Quindi ho trovato una nuova soluzione che funziona davvero!

app.use(function(req, res, next) {
    res.status(404).send('Unable to find the requested resource!');
});

Oppure puoi persino renderlo in una pagina 404.

app.use(function(req, res, next) {
    res.status(404).render("404page");
});

Spero che questo ti abbia aiutato!

app.get('*',function(req,res){
 res.redirect('/login');
});