ExpressJS में एक पृष्ठ पर 404 त्रुटियों को पुनर्निर्देशित कैसे करें?

203

मैं यह करने के लिए एक समारोह नहीं जानता, क्या किसी को एक का पता है?

node.js express

274

मुझे यह उदाहरण काफी मददगार लगा:

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

तो यह वास्तव में यह हिस्सा है:

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

— फेलिक्स
स्रोत

कृपया "संभाला" परिभाषित करें? मार्ग को वास्तव में क्या संभाला है?

— टिमो हुओवेनन

1

मुझे लगता है कि उस बिंदु तक कोई मिलान मार्ग नहीं मिला।

— फेलिक्स

2

FYI करें, का उपयोग app.routerअब हटा दिया गया है। देखें github.com/strongloop/express/wiki/...

— iX3

2

JSON प्रतिक्रिया के लिए res.jsonइसके बजाय इसका उपयोग करना बेहतर हो सकता है res.send()। वे आपके कोड में भी ऐसा ही व्यवहार res.jsonकरेंगे, लेकिन ऑटो-कंवर्टिंग ऑब्जेक्ट्स में स्ट्रिंग्स में कुछ जादू का उपयोग करेंगे जहां .send()नहीं होगा। माफी से अधिक सुरक्षित। expressjs.com/api.html#res.json

— wgp

9

अब यह प्रश्न FAQ एक्सप्रेस

— इवान फ्रैक्सेडेस

157

मुझे लगता है कि आपको पहले अपने सभी मार्गों को परिभाषित करना चाहिए और अंतिम मार्ग के रूप में जोड़ना चाहिए

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

एक उदाहरण ऐप जो काम करता है:

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?

— अल्फ्रेड
स्रोत

6

खैर ... समस्या यह है कि "*" .js और .css फ़ाइलों से पहले ही मेल खाता है, और वे ऐप में निर्दिष्ट नहीं हैं ... ठीक है, मुझे नहीं पता कि क्या वास्तव में पकड़ने का कोई तरीका है? एक ही बात है कि 404 त्रुटि, या "प्राप्त नहीं कर सकता ..." संदेश को अधिलेखित करने का एक तरीका है। वैसे भी, धन्यवाद

1

क्या आप स्थैतिक मिडलवेयर का उपयोग कर रहे हैं, क्योंकि तब भी आप स्थैतिक फ़ाइलों की सेवा कर सकते हैं?

— अल्फ्रेड

4

app.get('/public/*', function(req, res){ res.sendfile(__dirname + '/public/' + req.url); })आप स्थैतिक फ़ाइलों को भेजने के लिए इस मार्ग का उपयोग कर सकते हैं। यह ऊपर "*" मार्ग के साथ ठीक काम करता है। app.use(express.static(__dirname + '/public'));मेरे लिए काम नहीं करता है, वायर्ड।

— क्रिस

25

यह मेरे लिए काम नहीं कर रहा था, लेकिन फिर मुझे पता चला कि मेरे app.use(express.static(...))बाद आया था app.use(app.router)। एक बार जब मैंने उन्हें स्विच किया तो यह सब ठीक हो गया।

— स्टीफन

5

अपने जवाब में @ स्टीफन की टिप्पणी जोड़ने के लिए +1। यह मेरे लिए तब तक काम नहीं आया जब तक मैंने app.use (app.router) AFTER app.use (express.static (...)) नहीं

— डाला

37

आप अंतिम स्थिति में एक मिडलवेयर डाल सकते हैं जो एक NotFoundत्रुटि फेंकता है ,
या यहां तक कि सीधे 404 पृष्ठ को प्रस्तुत करता है:

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

— गणेश कुमार
स्रोत

9

कृपया अगली बार थोड़ा और अधिक जवाब देने पर विचार करें ... उदाहरण आमतौर पर ठीक होते हैं - और यह एक अच्छा उदाहरण है - लेकिन कुछ स्पष्टीकरण बहुत, बहुत अच्छे भी हो सकते हैं ...

— टॉनी मैडसेन

2

+1 बहुत अच्छा! मुझे लगता है कि यह अंतिम मार्ग से बेहतर है, क्योंकि इस तरह से आपको अंतिम समय पर use()अपने पास नहीं है app.router। (जैसा कि मेरे मामले में)

— अल्बा मेंडेज़

इसके अलावा, यह किसी भी अनुरोध पर डिफ़ॉल्ट व्यवहार को बदलता है (न केवल GETएस)। POSTअन्य विधि के साथ यादृच्छिक URL का प्रयास करें ; यह डिफ़ॉल्ट लौटा देगा Cannot POST...। एक हमलावर को तब पता चलेगा कि आप Express.JS का उपयोग कर रहे हैं।

— अल्बा मेंडेज़

बहुत अच्छा ईजे का उपयोग करने के अलावा आपको बस res.render('404')

— लगाना होगा

यह भी शायद एक स्थिति (404) res.status (404) .render ('404') होना चाहिए

— मार्टिनवेब

32

उपरोक्त उत्तर अच्छे हैं, लेकिन इनमें से आधे में आपको 404 नहीं मिलेंगे क्योंकि आपका HTTP स्टेटस कोड वापस आ गया है और दूसरे आधे हिस्से में, आप कस्टम टेम्पलेट रेंडर नहीं कर पाएंगे। Expressjs में कस्टम त्रुटि पृष्ठ (404) का सबसे अच्छा तरीका है

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

इस कोड को अपने सभी URL मैपिंग के अंत में रखें।

— सुशांत गुप्ता
स्रोत

@ सुशांतगुप्त - 'मान्य अस्तित्वपरक URL मैपिंग' से आपका क्या तात्पर्य है?

— जोनाथन Bechtel

@JonathanBechtel जैसा कि आपके गैर-गलत URL मार्गों के बाद उपरोक्त कोड ब्लॉक में है।

— सुशांत गुप्ता

6

App.js के अंतिम पंक्ति में बस इस समारोह में डाल दिया। यह डिफ़ॉल्ट पृष्ठ-नहीं-पाया त्रुटि पृष्ठ को ओवरराइड करेगा:

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

यह उन सभी अनुरोधों को ओवरराइड कर देगा जिनके पास एक वैध हैंडलर नहीं है और अपने स्वयं के त्रुटि पृष्ठ को प्रस्तुत करना है।

— विवेक बाजपेयी
स्रोत

2

यह आपकी "app.js की अंतिम पंक्ति" टिप्पणी थी जिसने मदद की! धन्यवाद!

— C0NFUS3D

मेरे ऐप में एक सुविधा जोड़ी गई। धन्यवाद :)

— प्रमेश बजराचार्य

5

आपके प्रश्न का उत्तर है:

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

और इस बारे में एक शानदार लेख है कि यह यहां सबसे अच्छा तरीका क्यों है ।

— मारियस कोटोफ़ाना
स्रोत

1

बीच क्या अंतर है sendऔर end?

— तिमु हुओविनन

मुझे लगता है कि उसे मिस-राइट होना चाहिएsend

— जैद अबू खलफ

4

एक्सप्रेस-एरर-हैंडलर से आप अपनी त्रुटियों के लिए कस्टम टेम्प्लेट, स्टैटिक पेज या एरर हैंडलर निर्दिष्ट कर सकते हैं। यह अन्य उपयोगी त्रुटि से निपटने वाली चीजें भी करता है जिन्हें हर ऐप को लागू करना चाहिए, जैसे 4xx त्रुटि डॉस हमलों से बचाव, और अपरिवर्तनीय त्रुटियों पर सुशोभित बंद। यहां बताया गया है कि आप क्या कर रहे हैं:

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

या एक कस्टम हैंडलर के लिए:

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

या एक कस्टम दृश्य के लिए:

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

— एरिक इलियट
स्रोत

4

कुछ ऐसे मामले हैं जहां 404 पृष्ठ को अंतिम मार्ग के रूप में निष्पादित करने के लिए नहीं लिखा जा सकता है, खासकर यदि आपके पास एक अतुल्यकालिक रूटिंग फ़ंक्शन है जो पार्टी के अंत में / मार्ग में लाता है। नीचे दिए गए पैटर्न को उन मामलों में अपनाया जा सकता है।

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

— डेनिस मैथ्यू फिलिप
स्रोत

2

शानदार, धन्यवाद! एकमात्र उत्तर (?) जो एक्सप्रेस के रैखिक प्रसंस्करण पर निर्भर नहीं करता है (यानी "अंत में त्रुटि हैंडलर डाल दिया")।

— Nick Grealy

3

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

यह नोड-बॉयलरप्लेट क्या करता है।

— ललित
स्रोत

2

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

— आशीष रंजन
स्रोत

2

सबसे आसान तरीका यह है कि एरर पेज के लिए सभी को पकड़ना है

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

फिर

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

अब आप अपने सभी "html" पृष्ठों (एक त्रुटि "html" पृष्ठ सहित) को एक चर में संग्रहीत कर सकते हैं

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

अब आप बस गेट मेथड का उपयोग करके पेजों को कॉल करते हैं और किसी भी मार्ग के लिए सभी कैच पकड़ सकते हैं जो 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);
});

पोर्ट सेट करना और सर्वर के लिए सुनना न भूलें:

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

यह अब सभी गैर-मान्यता प्राप्त समापन बिंदुओं के लिए अपना त्रुटि पृष्ठ दिखाना चाहिए!

— कीन अमरल
स्रोत

1

जबकि उपरोक्त उत्तर सही हैं, उन लोगों के लिए जो इस काम को IISNODE में प्राप्त करना चाहते हैं, जिन्हें आपको भी निर्दिष्ट करना होगा

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

अपने web.config में (अन्यथा IIS आपका आउटपुट खाएगा)।

— laktak
स्रोत

2

धन्यवाद!!! आप इंटरनेट पर एकमात्र ऐसे व्यक्ति हैं जो ऐसा जान पड़ता है कि (या कम से कम उसे साझा करें)! चीयर्स

— आंद्रे लुकास

1

आप सामग्री-प्रकार के अनुसार हैंडलिंग में त्रुटि कर सकते हैं

इसके अतिरिक्त, स्थिति कोड के अनुसार हैंडलिंग।

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

यदि आप res.format का उपयोग कर सकते हैं, तो आप सरल त्रुटि हैंडलिंग कोड लिख सकते हैं।

के res.format()बजाय सिफारिश res.accepts()।

यदि पिछले कोड में 500 त्रुटि होती है, तो if(500 == err.status){. . . }इसे कहा जाता है

— 멍개 -mung
स्रोत

1

हाय कृपया जवाब ढूंढो

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

— कृष्णमूर्ति आचार्य
स्रोत

0

यदि आप एक्सप्रेस-जनरेटर पैकेज का उपयोग करते हैं:

अगले (गलती);

यह कोड आपको 404 मिडलवेयर पर भेजता है।

— जोस्यू डीआज़
स्रोत

0

एक कस्टम पृष्ठ पर भेजने के लिए:

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

— क्रिस्टियन
स्रोत

0

मैंने स्टैटिक .ejsफ़ाइल के साथ 404 त्रुटि को संभालने के लिए नीचे दिए गए हैंडलर का उपयोग किया ।

इस कोड को रूट स्क्रिप्ट में डालें और फिर इसके file.jsमाध्यम app.use()से अपने app.js/ server.js/ www.js(अगर NelliJS के लिए IntelliJ का उपयोग कर) की आवश्यकता है

आप स्टैटिक .htmlफाइल का भी उपयोग कर सकते हैं ।

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

इस तरह, रनिंग एक्सप्रेस सर्वर एक उचित प्रतिक्रिया देगा 404 errorऔर आपकी वेबसाइट में एक पृष्ठ भी शामिल हो सकता है जो सर्वर की 404 प्रतिक्रिया को ठीक से प्रदर्शित करता है। तुम भी एक को शामिल कर सकते navbarमें है कि 404 error templateअपनी वेबसाइट के अन्य महत्वपूर्ण सामग्री है कि लिंक।

— मृदुक पटल
स्रोत

0

यदि आप अपने कार्यों (मार्गों) से त्रुटि पृष्ठों पर पुनर्निर्देशित करना चाहते हैं तो निम्नलिखित बातें करें -

अपने 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')
})

अपने फ़ंक्शन में, त्रुटि-पृष्ठ पुनर्निर्देशित का उपयोग करने के बजाय आप पहले त्रुटि स्थिति सेट कर सकते हैं और फिर कोड का उपयोग कर सकते हैं () उपरोक्त कोड के माध्यम से जाने के लिए कोड प्रवाह -
```
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()
}
```

— अंशुल बिष्ट
स्रोत

0

404 पृष्ठ को app.listen पर कॉल करने से ठीक पहले सेट किया जाना चाहिए। मार्ग मार्गों में * के लिए समर्थन है। यह एक विशेष चरित्र है जो किसी भी चीज से मेल खाता है। इसका उपयोग रूट हैंडलर बनाने के लिए किया जा सकता है जो सभी अनुरोधों से मेल खाता है।

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

— रजत
स्रोत

0

सभी HTTP क्रियाओं को कवर करना `express`

सभी HTTP क्रियाओं और आपके द्वारा उपयोग किए जा सकने वाले सभी शेष रास्तों को कवर करने के लिए :

app.all('*', cb)

अंतिम समाधान ऐसा लगेगा:

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

आपको अंत में राउटर डालना नहीं भूलना चाहिए। क्योंकि राउटर का क्रम मायने रखता है।

— NGS
स्रोत

0

उपरोक्त कोड मेरे लिए काम नहीं किया।

तो मुझे एक नया समाधान मिला जो वास्तव में काम करता है!

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

या आप इसे 404 पेज पर भी प्रस्तुत कर सकते हैं।

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

आशा है कि इसने आपकी मदद की!

— जॉन टैसी
स्रोत

-3

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

— श्रीनिवास
स्रोत

ExpressJS में एक पृष्ठ पर 404 त्रुटियों को पुनर्निर्देशित कैसे करें?

app.js:

सभी HTTP क्रियाओं को कवर करना express

सभी HTTP क्रियाओं को कवर करना `express`