¿Cómo redirigir los errores 404 a una página en ExpressJS?

No conozco una función para hacer esto, ¿alguien sabe de una?

Encontré este ejemplo bastante útil:

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

Entonces, en realidad es esta 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');
});

Creo que primero debes definir todas tus rutas y como la última ruta agregar

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

Una aplicación de ejemplo que funciona:

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?

Puede colocar un middleware en la última posición que arroje un NotFounderror,
o incluso muestre la página 404 directamente:

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

Las respuestas anteriores son buenas, pero en la mitad de estas no obtendrá 404 cuando se devuelva su código de estado HTTP y en la otra mitad, no podrá tener una plantilla personalizada renderizada. La mejor manera de tener una página de error personalizada (404) en Expressjs es

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

Coloque este código al final de todas sus asignaciones de URL.

En la última línea de app.js simplemente pon esta función. Esto anulará la página de error predeterminada de página no encontrada:

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

Anulará todas las solicitudes que no tengan un controlador válido y generará su propia página de error.

La respuesta a tu pregunta es:

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

Y hay un gran artículo sobre por qué es la mejor manera aquí .

express-error-handler le permite especificar plantillas personalizadas, páginas estáticas o manejadores de errores para sus errores. También hace otras cosas útiles para el manejo de errores que toda aplicación debería implementar, como proteger contra los ataques de error 4xx de DOS y el apagado correcto de errores irrecuperables. Así es como haces lo que estás pidiendo:

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 para un controlador personalizado:

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

O para una vista personalizada:

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

Hay algunos casos en los que la página 404 no se puede escribir para ejecutarse como la última ruta, especialmente si tiene una función de enrutamiento asíncrono que trae una ruta / tarde a la fiesta. El siguiente patrón podría adoptarse en esos casos.

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

Esto es lo que hace node-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');
  });

La forma más fácil de hacerlo es tener un catch all para la página de error

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

Luego

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

Ahora puede almacenar todas sus páginas "html" (incluida una página de error "html") en una variable

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

Ahora simplemente llame a las páginas con el Método Get y obtenga una captura de todas las rutas que no estén disponibles para dirigirlas a su página de error usando 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);
});

No olvide configurar un puerto y escuchar el servidor:

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

¡Ahora debería mostrar su página de error para todos los puntos finales no reconocidos!

Si bien las respuestas anteriores son correctas, para aquellos que desean que esto funcione en IISNODE, también deben especificar

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

en su web.config (de lo contrario, IIS se comerá su salida).

puede cometer errores de acuerdo con el tipo de contenido

Además, manejo de acuerdo con el código de estado.

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

Si puede usar res.format, puede escribir un código simple de manejo de errores.

Recomendación en res.format()lugar de res.accepts().

Si el error 500 ocurre en el código anterior, if(500 == err.status){. . . }se llama

Hola por favor encuentra la respuesta

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

Si usa el paquete express-generator:

siguiente (err);

Este código lo envía al middleware 404.

Para enviar a una página personalizada:

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

Usé el siguiente controlador para manejar el error 404 con un .ejsarchivo estático .

Pon este código en un script ruta y luego requerir que file.jsa través app.use()de su app.js/ server.js/ www.js(si se utiliza para IntelliJ NodeJS)

También puedes usar un .htmlarchivo estático .

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

De esta manera, el servidor express en ejecución responderá con una respuesta adecuada 404 errory su sitio web también puede incluir una página que muestre correctamente la respuesta 404 del servidor. También puede incluir una navbaren la que 404 error templateque los enlaces a otros contenidos importantes de su sitio web.

Si desea redirigir a páginas de error desde sus funciones (rutas), haga lo siguiente:

1. Agregue un código de mensaje de error general en su 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. En su función, en lugar de utilizar una redirección de página de error, puede establecer primero el estado del error y luego utilizar next () para que el flujo de código pase por el código anterior:

   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 página 404 debe configurarse justo antes de la llamada a app.listen.Express tiene soporte para * en rutas de ruta. Este es un personaje especial que coincide con cualquier cosa. Esto se puede usar para crear un controlador de ruta que coincida con todas las solicitudes.

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

Cubriendo todos los verbos HTTP en express

Para cubrir todos los verbos HTTP y todas las rutas restantes, puede usar:

app.all('*', cb)

La solución final se vería así:

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

No debes olvidar poner el enrutador al final. Porque el orden de los enrutadores es importante.

El código anterior no funcionó para mí.

¡Así que encontré una nueva solución que realmente funciona!

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

O incluso puede representarlo en una página 404.

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

Espero que esto te haya ayudado!

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