node.js - not - node js error page

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

Question

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

Answer 1

Creo que primero deberías 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.send(''what???'', 404);
});

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?

Answer 2

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

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

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

Answer 3

Encontré este ejemplo bastante útil:

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

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

Answer 4

Hay algunos casos en los que no se puede escribir la página 404 para que se ejecute como la última ruta, especialmente si tiene una función de enrutamiento asíncrono que trae una ruta / tarde a la fiesta. El patrón a continuación podría ser adoptado 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");
});

Answer 5

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 here .

Answer 6

Las respuestas anteriores son buenas, pero en la mitad de ellas no recibirás 404 a medida que devuelvas tu código de estado HTTP y en la otra mitad, no podrás tener un renderizado de plantilla personalizado. La mejor forma 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.

Answer 7

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

Answer 8

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

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

Answer 9

Si bien las respuestas anteriores son correctas, para aquellos que quieran hacer 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).

Answer 10

Si usa el paquete de generador expreso:

siguiente (err);

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

Answer 11

puede manejar errores según el tipo de contenido

Además, la manipulación 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 código de manejo de errores simple.

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

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

Answer 12

express-error-handler permite especificar plantillas personalizadas, páginas estáticas o manejadores de errores para sus errores. También realiza otras tareas útiles para el manejo de errores que debe implementar cada aplicación, como proteger contra los errores de error 4xx de DOS y el cierre ordenado 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''
  }
});

Answer 13

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

Esto es lo que hace node-boilerplate.

Answer 14

.ejs el controlador a continuación para manejar el error 404 con un archivo .ejs estático.

Coloque este código en un script de ruta y luego solicite ese file.js través de app.use() en su app.js / server.js / www.js (si usa IntelliJ para NodeJS)

También puede usar un archivo .html estático.

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

De esta forma, el servidor Express en ejecución responderá con un 404 error apropiado y su sitio web también puede incluir una página que muestre correctamente la respuesta 404 del servidor correctamente. También puede incluir una navbar de navbar en esa 404 error template que enlaza con otro contenido importante de su sitio web.

Answer 15

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

Answer 16

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