Comment rediriger les erreurs 404 vers une page dans ExpressJS?
Je ne connais pas de fonction pour faire cela, est-ce que quelqu'un en connaît une?
J'ai trouvé cet exemple très utile:
https://github.com/visionmedia/express/blob/master/examples/error-pages/index.js
C'est donc cette partie:
// "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');
});
Je pense que vous devriez d’abord définir tous vos itinéraires et ajouter le dernier itinéraire
//The 404 Route (ALWAYS Keep this as the last route)
app.get('*', function(req, res){
res.status(404).send('what???');
});
Un exemple d'application qui fonctionne:
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?
Vous pouvez mettre un middleware à la dernière position qui génère une erreur NotFound,
ou même rend la page 404 directement:
app.use(function(req,res){
res.status(404).render('404.jade');
});
Les réponses ci-dessus sont bonnes, mais dans la moitié d'entre elles, votre code de statut HTTP n'est pas renvoyé à 404 et dans l'autre moitié, vous ne pourrez pas restituer un modèle personnalisé. La meilleure façon d’avoir une page d’erreur personnalisée (404) dans Expressjs est:
app.use(function(req, res, next){
res.status(404).render('404_error_template', {title: "Sorry, page not found"});
});
Placez ce code à la fin de tous vos mappages d'URL.
La réponse à votre question est la suivante:
app.use(function(req, res) {
res.status(404).end('error');
});
Et il y a un excellent article sur pourquoi c'est la meilleure façon ici .
À la dernière ligne de app.js, mettez simplement cette fonction. Cela remplacera la page d'erreur par défaut page-not-found:
app.use(function (req, res) {
res.status(404).render('error');
});
Il remplacera toutes les demandes sans gestionnaire valide et affichera votre propre page d'erreur.
Dans certains cas, il est impossible d'écrire une page 404 pour qu'elle soit exécutée en tant que dernier itinéraire, notamment si vous disposez d'une fonction de routage asynchrone qui amène un/itinéraire en retard à la partie. Le modèle ci-dessous pourrait être adopté dans ces cas.
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
C'est ce que fait le nœud-boilerplate.
express-error-handler vous permet de spécifier des modèles personnalisés, des pages statiques ou des gestionnaires d’erreurs pour vos erreurs. Il effectue également d'autres opérations utiles de gestion des erreurs que chaque application doit implémenter, telles que la protection contre les attaques DOS 4xx et un arrêt progressif des erreurs irrécupérables. Voici comment vous faites ce que vous demandez:
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 pour un gestionnaire personnalisé:
handler = errorHandler({
handlers: {
'404': function err404() {
// do some custom thing here...
}
}
});
Ou pour une vue personnalisée:
handler = errorHandler({
views: {
'404': '404.jade'
}
});
// 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');
});
Salut s'il vous plaît trouver la réponse
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}!`));
vous pouvez gérer les erreurs en fonction du type de contenu
En outre, la gestion en fonction du code d'état.
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 vous pouvez utiliser res.format, vous pouvez écrire un code simple de traitement des erreurs.
Recommandation res.format() au lieu de res.accepts().
Si l'erreur 500 se produit dans le code précédent, if(500 == err.status){. . . } est appelé
Bien que les réponses ci-dessus soient correctes, pour ceux qui souhaitent que cela fonctionne dans IISNODE, vous devez également spécifier
<configuration>
<system.webServer>
<httpErrors existingResponse="PassThrough"/>
</system.webServer>
<configuration>
dans votre web.config (sinon IIS mangera votre sortie).
Le moyen le plus simple de le faire est d’avoir un piège pour la page d’erreur
// Step 1: calling express
const express = require("express");
const app = express();
Ensuite
// require Path to get file locations
const path = require("path");
Maintenant, vous pouvez stocker toutes vos pages "html" (y compris une page d'erreur "html") dans une 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
Maintenant, il vous suffit d'appeler les pages à l'aide de la méthode Get et de saisir toutes les routes non disponibles pour vous diriger directement vers votre page d'erreur à l'aide de 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'oubliez pas de configurer un port et d'écouter le serveur:
// Setting port to listen on
const port = process.env.PORT || 8000;
// Listening on port
app.listen(port, function(){
console.log(`http://localhost:${port}`);
})
Cela devrait maintenant afficher votre page d'erreur pour tous les points finaux non reconnus!
J'ai utilisé le gestionnaire ci-dessous pour gérer l'erreur 404 avec un fichier .ejs statique.
Placez ce code dans un script de routage, puis indiquez file.js à app.use() dans votre app.js/server.js/www.js (si vous utilisez IntelliJ pour NodeJS)
Vous pouvez également utiliser un fichier .html statique.
//Unknown route handler
router.get("[otherRoute]", function(request, response) {
response.status(404);
response.render("error404.[ejs]/[html]");
response.end();
});
De cette façon, le serveur express en cours d’exécution répondra avec un 404 error approprié et votre site Web peut également inclure une page affichant correctement la réponse 404 du serveur. Vous pouvez également inclure une navbar dans ce 404 error template qui renvoie à un autre contenu important de votre site Web.
Si vous utilisez le paquet express-generator:
next (err);
Ce code vous envoie au middleware 404.
Pour envoyer à une page personnalisée:
app.get('*', function(req, res){
if (req.accepts('html')) {
res.send('404', '<script>location.href = "/the-404-page.html";</script>');
return;
}
});
Si vous souhaitez rediriger les pages d'erreur depuis vos fonctions (routes), procédez comme suit:
Ajoutez un code de message d'erreur général dans votre 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') })Dans votre fonction, au lieu d'utiliser une redirection de page d'erreur, vous pouvez d'abord définir le statut de l'erreur, puis utiliser next () pour que le flux de code passe par le code ci-dessus -
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() }