Como redirect erros 404 para uma página no ExpressJS?

Eu não conheço uma function para fazer isso, alguém sabe de um?

Eu achei este exemplo bastante útil:

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

Então é realmente essa 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'); }); 

Eu acho que você deve primeiro definir todas as suas rotas e como a última rota adicionar

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

Um aplicativo de exemplo 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? 

Você pode colocar um middleware na última posição que lança um erro NotFound ,
ou até mesmo processa a página 404 diretamente:

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

As respostas acima são boas, mas em metade delas você não estará recebendo 404 quando seu código de status HTTP for retornado e na outra metade, você não poderá ter um renderizador de modelo personalizado. A melhor maneira de ter uma página de erro personalizada (404’s) no Expressjs é

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

Coloque este código no final de todos os seus mapeamentos de URL.

A resposta para sua pergunta é:

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

E há um ótimo artigo sobre por que é o melhor caminho aqui .

Na última linha de app.js, basta colocar essa function. Isso replaceá a página de erro padrão não encontrada na página:

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

Ele replaceá todas as solicitações que não tiverem um manipulador válido e renderizar sua própria página de erro.

O express-error-handler permite que você especifique modelos personalizados, páginas estáticas ou manipuladores de erro para seus erros. Ele também faz outras coisas úteis de manipulação de erros que cada aplicativo deve implementar, como proteção contra ataques de DOS de erro 4xx e desligamento normal em erros irrecuperáveis. Veja como você faz o que está pedindo:

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

Ou para um manipulador personalizado:

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

Ou para uma visualização personalizada:

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

Existem alguns casos em que a página 404 não pode ser gravada para ser executada como a última rota, especialmente se você tiver uma function de roteamento assíncrona que traga um / route para a parte. O padrão abaixo pode ser adotado nesses 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"); }); 
 // 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'); }); 

Embora as respostas acima estejam corretas, para aqueles que querem que isso funcione no IISNODE, você também precisa especificar

      

no seu web.config (caso contrário o IIS irá consumir sua saída).

você pode manipular erros de acordo com o tipo de conteúdo

Além disso, o manuseio de acordo com o código de status.

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 você pode usar res.format, você pode escrever código de tratamento de erro simples.

Recomendação res.format() vez de res.accepts() .

Se o erro 500 ocorrer no código anterior, if(500 == err.status){. . . } if(500 == err.status){. . . } if(500 == err.status){. . . } é chamado

Se você usar o pacote express-generator:

próximo (err);

Esse código te manda para o middleware 404.

Para enviar para uma página personalizada:

 app.get('*', function(req, res){ if (req.accepts('html')) { res.send('404', ''); return; } }); 

Eu usei o manipulador abaixo para manipular o erro 404 com um arquivo .ejs estático.

Coloque este código em um script de rota e, em seguida, exija que file.js através de app.use() em seu app.js / server.js / www.js (se estiver usando o IntelliJ for NodeJS)

Você também pode usar um arquivo .html estático.

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

Dessa forma, o servidor expresso em execução responderá com um 404 error adequado e seu site também poderá include uma página que exiba corretamente a resposta 404 do servidor corretamente. Você também pode include uma navbar nesse 404 error template que vincula a outro conteúdo importante do seu site.

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

A maneira mais fácil de fazer isso é ter uma captura de todos para a página de erro

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

Então

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

Agora você pode armazenar todas as suas páginas “html” (incluindo uma página de erro “html”) em uma variável

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

Agora você simplesmente chama as páginas usando o método Get e captura todas as rotas não disponíveis para direcionar à sua página de erro 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); }); 

Não esqueça de configurar um servidor Port and Listen for:

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

Agora, isso deve mostrar sua página de erro para todos os endpoints não reconhecidos!

Se você quiser redirect para páginas de erro de suas funções (rotas), faça as seguintes coisas –

  1. Adicione o código geral de mensagens de erro em seu 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. Em sua function, em vez de usar um redirecionamento de página de erro, você pode definir primeiro o status de erro e, em seguida, usar next () para o stream de código passar pelo código acima –

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