Node.js
एक्सप्रेस के साथ वेब ऐप्स

परिचय

वाक्य - विन्यास

• app.get (पथ [, मिडलवेयर], कॉलबैक [, कॉलबैक ...])
• app.put (पथ [, मिडलवेयर], कॉलबैक [, कॉलबैक ...])
• app.post (पथ [, मिडलवेयर], कॉलबैक [, कॉलबैक ...])
• ऐप ['डिलीट'] (पथ [, मिडलवेयर], कॉलबैक [, कॉलबैक ...])
• app.use (पथ [, मिडलवेयर], कॉलबैक [, कॉलबैक ...])
• app.use (कॉलबैक)

पैरामीटर

शुरू करना

आपको सबसे पहले एक निर्देशिका है, यह पहुँच अपने खोल में बना सकते हैं और का उपयोग कर एक्सप्रेस स्थापित करना होगा NPM चलाकर npm install express --save

एक फ़ाइल बनाएं और इसे app.js नाम app.js और निम्नलिखित कोड जोड़ें जो एक नया एक्सप्रेस सर्वर बनाता है और app.get साथ एक एंडपॉइंट जोड़ता है ( /ping ):

const express = require('express');

const app = express();

app.get('/ping', (request, response) => {
    response.send('pong');
});

app.listen(8080, 'localhost');

अपनी स्क्रिप्ट चलाने के लिए अपने शेल में निम्न कमांड का उपयोग करें:

> node app.js

आपका एप्लिकेशन लोकलहोस्ट पोर्ट 8080 पर कनेक्शन स्वीकार करेगा। यदि hostname का तर्क app.listen पर छोड़ा गया है, तो सर्वर मशीन के IP पते के साथ-साथ लोकलहोस्ट पर भी कनेक्शन स्वीकार करेगा। यदि पोर्ट मान 0 है, तो ऑपरेटिंग सिस्टम उपलब्ध पोर्ट को असाइन करेगा।

एक बार जब आपकी स्क्रिप्ट चल रही हो, तो आप सर्वर से अपेक्षित प्रतिक्रिया, "पोंग" प्राप्त करने के लिए इसे शेल में टेस्ट कर सकते हैं:

> curl http://localhost:8080/ping
pong

आप वेब ब्राउज़र भी खोल सकते हैं, आउटपुट देखने के लिए url http: // localhost: 8080 / ping पर नेविगेट करें

बुनियादी मार्ग

सबसे पहले एक एक्सप्रेस ऐप बनाएं:

const express = require('express');
const app = express();

तब आप इस तरह से मार्गों को परिभाषित कर सकते हैं:

app.get('/someUri', function (req, res, next) {})

यह संरचना सभी HTTP विधियों के लिए काम करती है, और पहले तर्क के रूप में एक पथ की अपेक्षा करती है, और उस पथ के लिए एक हैंडलर, जो अनुरोध और प्रतिक्रिया ऑब्जेक्ट प्राप्त करता है। तो, मूल HTTP विधियों के लिए, ये मार्ग हैं

// GET www.domain.com/myPath
app.get('/myPath', function (req, res, next) {})

// POST www.domain.com/myPath
app.post('/myPath', function (req, res, next) {})

// PUT www.domain.com/myPath
app.put('/myPath', function (req, res, next) {})

// DELETE www.domain.com/myPath
app.delete('/myPath', function (req, res, next) {})

आप यहाँ समर्थित क्रियाओं की पूरी सूची देख सकते हैं । यदि आप एक मार्ग और सभी HTTP विधियों के लिए समान व्यवहार को परिभाषित करना चाहते हैं, तो आप इसका उपयोग कर सकते हैं:

app.all('/myPath', function (req, res, next) {}) 

या

app.use('/myPath', function (req, res, next) {})

या

app.use('*', function (req, res, next) {})

// * wildcard will route for all paths

आप एक मार्ग के लिए अपनी मार्ग परिभाषाओं को श्रृंखलाबद्ध कर सकते हैं

app.route('/myPath')
  .get(function (req, res, next) {})
  .post(function (req, res, next) {})
  .put(function (req, res, next) {})

आप किसी भी HTTP मेथड में फंक्शन्स को भी जोड़ सकते हैं। वे अंतिम कॉलबैक से पहले चलेंगे और तर्कों के रूप में पैरामीटर (req, res, next) लेंगे।

// GET www.domain.com/myPath
app.get('/myPath', myFunction, function (req, res, next) {})

आपके अंतिम कॉलबैक को एक फ़ाइल में बहुत अधिक कोड डालने से बचने के लिए किसी बाहरी फ़ाइल में संग्रहीत किया जा सकता है:

// other.js
exports.doSomething = function(req, res, next) {/* do some stuff */};

और फिर आपके रूट वाली फाइल में:

const other = require('./other.js');
app.get('/someUri', myFunction, other.doSomething);

इससे आपका कोड बहुत अधिक साफ हो जाएगा।

अनुरोध से जानकारी प्राप्त करना

का अनुरोध यूआरएल (सूचना है कि से जानकारी प्राप्त करने के req मार्गों के हैंडलर समारोह में अनुरोध वस्तु है)। इस मार्ग की परिभाषा /settings/:user_id और इस विशेष उदाहरण /settings/32135?field=name

// get the full path
req.originalUrl // => /settings/32135?field=name

// get the user_id param
req.params.user_id // => 32135     

// get the query value of the field
req.query.field // => 'name'

आप इस तरह अनुरोध के हेडर भी प्राप्त कर सकते हैं

req.get('Content-Type')
// "text/plain"

अन्य जानकारी प्राप्त करने के लिए आप बिचौलियों का उपयोग कर सकते हैं। उदाहरण के लिए, अनुरोध के शरीर की जानकारी प्राप्त करने के लिए, आप बॉडी-पार्सर मिडलवेयर का उपयोग कर सकते हैं, जो कच्चे अनुरोध वाले निकाय को बेकार प्रारूप में बदल देगा।

var app = require('express')();
var bodyParser = require('body-parser');

app.use(bodyParser.json()); // for parsing application/json
app.use(bodyParser.urlencoded({ extended: true })); // for parsing application/x-www-form-urlencoded

अब इस तरह एक अनुरोध मान लीजिए

PUT /settings/32135
{
  "name": "Peter"
}

आप पोस्ट किए गए नाम को इस तरह एक्सेस कर सकते हैं

req.body.name
// "Peter"

इसी तरह, आप अनुरोध से कुकीज़ तक पहुंच सकते हैं, आपको कुकी-पार्सर जैसे मिडलवेयर की भी आवश्यकता होती है

req.cookies.name

मॉड्यूलर एक्सप्रेस आवेदन

एक्सप्रेस वेब अनुप्रयोग मॉड्यूलर उपयोग रूटर कारखानों बनाने के लिए:

मापांक:

// greet.js
const express = require('express');

module.exports = function(options = {}) { // Router factory
    const router = express.Router();

    router.get('/greet', (req, res, next) => {
        res.end(options.greeting);
    });

    return router;
};

आवेदन:

// app.js
const express = require('express');
const greetMiddleware = require('./greet.js');

express()
    .use('/api/v1/', greetMiddleware({ greeting:'Hello world' }))
    .listen(8080);

यह आपके एप्लिकेशन को मॉड्यूलर, अनुकूलन योग्य और आपके कोड को पुन: प्रयोज्य बना देगा।

http://<hostname>:8080/api/v1/greet एक्सेस करते समय आउटपुट Hello world

अधिक जटिल उदाहरण

सेवाओं के साथ उदाहरण जो मिडिलवेयर फैक्ट्री के फायदे दिखाता है।

मापांक:

// greet.js
const express = require('express');

module.exports = function(options = {}) { // Router factory
    const router = express.Router();
    // Get controller
    const {service} = options;

    router.get('/greet', (req, res, next) => {
        res.end(
            service.createGreeting(req.query.name || 'Stranger')
        );
    });

    return router;
};

आवेदन:

// app.js
const express = require('express');
const greetMiddleware = require('./greet.js');

class GreetingService {
    constructor(greeting = 'Hello') {
        this.greeting = greeting;
    }

    createGreeting(name) {
        return `${this.greeting}, ${name}!`;
    }
}

express()
    .use('/api/v1/service1', greetMiddleware({
        service: new GreetingService('Hello'),
    }))
    .use('/api/v1/service2', greetMiddleware({
        service: new GreetingService('Hi'),
    }))
    .listen(8080);

जब http://<hostname>:8080/api/v1/service1/greet?name=World आउटपुट Hello, World और http://<hostname>:8080/api/v1/service2/greet?name=World आउटपुट Hi, World ।

टेम्पलेट इंजन का उपयोग करना

टेम्पलेट इंजन का उपयोग करना

निम्न कोड जेड को टेम्पलेट इंजन के रूप में सेटअप करेगा। (नोट: जेड को नाम दिया गया है pug दिसंबर 2015 के रूप में)

const express = require('express');  //Imports the express module
const app = express();  //Creates an instance of the express module

const PORT = 3000; //Randomly chosen port

app.set('view engine','jade'); //Sets jade as the View Engine / Template Engine
app.set('views','src/views'); //Sets the directory where all the views (.jade files) are stored.

//Creates a Root Route
app.get('/',function(req, res){
    res.render('index');  //renders the index.jade file into html and returns as a response. The render function optionally takes the data to pass to the view.
});

//Starts the Express server with a callback
app.listen(PORT, function(err) {
    if (!err) {
        console.log('Server is running at port', PORT);
    } else {
        console.log(JSON.stringify(err));
    }
});

इसी प्रकार, अन्य खाका इंजन के रूप में भी इस तरह के प्रयोग किया जा सकता Handlebars ( hbs ) या ejs । याद रखें npm install टेम्पलेट इंजन भी npm install करें। Handlebars उपयोग हम के लिए hbs पैकेज, जेड के लिए हमारे पास एक jade पैकेज और EJS के लिए, हम एक है ejs पैकेज।

EJS टेम्पलेट उदाहरण

EJS (अन्य एक्सप्रेस टेम्प्लेट की तरह) के साथ, आप सर्वर कोड चला सकते हैं और अपने सर्वर वैरिएबल को आप HTML से एक्सेस कर सकते हैं।
EJS में इसे " <% " के रूप में स्टार्ट टैग और " %> " अंतिम टैग के रूप में उपयोग किया जाता है, जो रेंडर <%=var_name%> रूप में पारित किए गए चर का उपयोग <%=var_name%> का उपयोग करके किया जा सकता है।
उदाहरण के लिए, यदि आपके पास अपने सर्वर कोड में सरणी है
आप इसका उपयोग करके लूप कर सकते हैं

<h1><%= title %></h1>
   <ul>
<% for(var i=0; i<supplies.length; i++) { %>
    <li>
        <a href='supplies/<%= supplies[i] %>'>
            <%= supplies[i] %>
        </a>
    </li>
<% } %>

जैसा कि आप उदाहरण में देख सकते हैं कि हर बार जब आप सर्वर साइड कोड और HTML के बीच स्विच करते हैं, तो आपको वर्तमान ईजेएस टैग को बंद करने और बाद में एक नया खोलने की आवश्यकता होती है, यहां हम कमांड के for li बनाना चाहते थे इसलिए हमें अपना ईजेएस टैग बंद करने की आवश्यकता थी के अंत में for और सिर्फ कर्ली कोष्ठक के लिए नया टैग बनाना
एक और उदाहरण
यदि हम इनपुट डिफॉल्ट संस्करण को उस सर्वर की ओर से एक वेरिएबल के रूप में रखना चाहते हैं जिसका हम उपयोग करते हैं <%=
उदाहरण के लिए:

 Message:<br>
<input type="text" value="<%= message %>" name="message" required>

यहां आपके सर्वर की ओर से पास किया गया संदेश चर आपके इनपुट का डिफ़ॉल्ट मान होगा, कृपया ध्यान दें कि यदि आपने अपने सर्वर की ओर से संदेश चर को पारित नहीं किया है, तो ईजेएस एक अपवाद फेंक देगा। आप res.render('index', {message: message}); का उपयोग करके पैरामीटर पास कर सकते हैं res.render('index', {message: message}); (ईजेएस फ़ाइल के लिए index.ejs कहा जाता है)।

ईजेएस टैग में आप चाहें if , while या किसी अन्य जावास्क्रिप्ट कमांड का उपयोग कर सकते हैं।

ExpressJS के साथ JSON एपीआई

var express = require('express');
var cors = require('cors'); // Use cors module for enable Cross-origin resource sharing

var app = express();
app.use(cors()); // for all routes

var port = process.env.PORT || 8080;

app.get('/', function(req, res) {
    var info = {
        'string_value': 'StackOverflow',
        'number_value': 8476
    }
    res.json(info);

    // or
    /* res.send(JSON.stringify({
        string_value: 'StackOverflow',
        number_value: 8476
    })) */

  //you can add a status code to the json response
   /* res.status(200).json(info) */
})

app.listen(port, function() {
    console.log('Node.js listening on port ' + port)
})

http://localhost:8080/ आउटपुट ऑब्जेक्ट

{
    string_value: "StackOverflow",
    number_value: 8476
}

स्थिर फ़ाइलों की सेवा

एक्सप्रेस के साथ एक वेबसर्वर का निर्माण करते समय अक्सर गतिशील सामग्री और स्थिर फ़ाइलों के संयोजन की सेवा करना आवश्यक होता है।

उदाहरण के लिए, आपके पास index.html और script.js हो सकते हैं जो फ़ाइल सिस्टम में रखी गई स्थिर फाइलें हैं।

स्टैटिक फाइल्स रखने के लिए 'पब्लिक' नाम के फोल्डर का इस्तेमाल करना आम बात है। इस स्थिति में फ़ोल्डर की संरचना निम्न प्रकार दिख सकती है:

project root
├── server.js
├── package.json 
└── public
    ├── index.html
    └── script.js

यह स्थिर फ़ाइलों की सेवा के लिए एक्सप्रेस को कॉन्फ़िगर करने का तरीका है:

const express = require('express');
const app = express();

app.use(express.static('public'));

नोट: एक बार जब फ़ोल्डर कॉन्फ़िगर किया जाता है, index.html, script.js और "सार्वजनिक" फ़ोल्डर में सभी फाइलें रूट पथ पर उपलब्ध होंगी (आपको url में /public/ निर्दिष्ट नहीं करना चाहिए)। ऐसा इसलिए है, क्योंकि व्यक्त की गई फ़ाइलों के लिए एक्सप्रेस स्थिर फ़ोल्डर के सापेक्ष प्रकट होता है। आप नीचे दिखाए गए अनुसार आभासी पथ उपसर्ग निर्दिष्ट कर सकते हैं:

app.use('/static', express.static('public'));

/static/ उपसर्ग के तहत संसाधन उपलब्ध कराएगा।

एकाधिक फ़ोल्डर

एक ही समय में कई फ़ोल्डरों को परिभाषित करना संभव है:

app.use(express.static('public'));
app.use(express.static('images'));
app.use(express.static('files'));

संसाधन की सेवा करते समय एक्सप्रेस परिभाषा क्रम में फ़ोल्डर की जांच करेगा। समान नाम वाली फ़ाइलों के मामले में, पहले मिलान फ़ोल्डर में से एक को परोसा जाएगा।

Django शैली में नामित मार्ग

एक बड़ी समस्या यह है कि मूल्यवान नामित मार्गों को एक्सप्रेस आउट ऑफ द बॉक्स द्वारा समर्थित नहीं किया गया है। समाधान समर्थित तृतीय-पक्ष पैकेज स्थापित करना है, उदाहरण के लिए एक्सप्रेस-रिवर्स :

npm install express-reverse

इसे अपनी परियोजना में प्लग करें:

var app = require('express')();
require('express-reverse')(app);

फिर इसका उपयोग करें जैसे:

app.get('test', '/hello', function(req, res) {
  res.end('hello');
});

इस दृष्टिकोण के नकारात्मक पक्ष यह है कि आप उन्नत राउटर उपयोग में दिखाए गए अनुसार route एक्सप्रेस मॉड्यूल का उपयोग नहीं कर सकते । वर्कअराउंड को राउटर फैक्ट्री के पैरामीटर के रूप में आपके app को पास करना है:

require('./middlewares/routing')(app);

और इसका उपयोग करें:

module.exports = (app) => {
    app.get('test', '/hello', function(req, res) {
      res.end('hello');
    });
};

आप इसे अभी से पता लगा सकते हैं कि निर्दिष्ट कस्टम नामस्थानों के साथ विलय करने और उचित नियंत्रकों पर इंगित करने के लिए कार्यों को कैसे परिभाषित किया जाए।

गलती संभालना

बुनियादी त्रुटि से निपटने

डिफ़ॉल्ट रूप से, एक्सप्रेस प्रस्तुत करने के लिए /views निर्देशिका में 'त्रुटि' दृश्य की तलाश करेगा। बस 'त्रुटि' दृश्य बनाएं और त्रुटियों को संभालने के लिए इसे दृश्य निर्देशिका में रखें। त्रुटियों को त्रुटि संदेश, स्थिति और स्टैक ट्रेस के साथ लिखा जाता है, उदाहरण के लिए:

विचारों / error.pug

html
  body
      h1= message
      h2= error.status
      p= error.stack

उन्नत त्रुटि हैंडलिंग

मिडलवेयर फ़ंक्शन स्टैक के बहुत अंत में अपनी त्रुटि-हैंडलिंग मिडलवेयर फ़ंक्शंस को परिभाषित करें। उदाहरण के लिए तीन के बजाय चार तर्क हैं (err, req, res, next) :

app.js

// catch 404 and forward to error handler
app.use(function(req, res, next) {
    var err = new Error('Not Found');
    err.status = 404;

    //pass error to the next matching route.
    next(err);
});

// handle error, print stacktrace
app.use(function(err, req, res, next) {
    res.status(err.status || 500);

    res.render('error', {
        message: err.message,
        error: err
    });
});

आप नियमित मिडलवेयर फ़ंक्शंस के साथ ही कई एरर-हैंडलिंग मिडलवेयर फ़ंक्शंस को परिभाषित कर सकते हैं।

मिडलवेयर और अगले कॉलबैक का उपयोग करना

एक्सप्रेस हर रूट हैंडलर और मिडलवेयर फ़ंक्शन के लिए एक next कॉलबैक पास करता है जिसका उपयोग कई हैंडलर में एकल मार्गों के लिए तर्क तोड़ने के लिए किया जा सकता है। बिना किसी तर्क के next() को कॉल करना अगले मिलान मिडिलवेयर या रूट हैंडलर को जारी रखने के लिए व्यक्त करता है। किसी त्रुटि के साथ next(err) कॉलिंग किसी भी त्रुटि हैंडलर मिडलवेयर को ट्रिगर करेगी। next('route') कॉलिंग वर्तमान मार्ग पर किसी भी बाद के मिडलवेयर को बायपास करेगी और अगले मिलान मार्ग पर जाएगी। यह डोमेन लॉजिक को पुन: प्रयोज्य घटकों में डिकॉय करने की अनुमति देता है जो स्व-निहित होते हैं, परीक्षण करने में सरल होते हैं, और बनाए रखने और बदलने में आसान होते हैं।

एकाधिक मिलान मार्ग

/api/foo या /api/bar लिए अनुरोध सदस्य को देखने के लिए प्रारंभिक हैंडलर को चलाएगा और फिर प्रत्येक मार्ग के लिए वास्तविक हैंडलर को नियंत्रित करेगा।

app.get('/api', function(req, res, next) {
  // Both /api/foo and /api/bar will run this
  lookupMember(function(err, member) {
    if (err) return next(err);
    req.member = member;
    next();
  });
});

app.get('/api/foo', function(req, res, next) {
  // Only /api/foo will run this
  doSomethingWithMember(req.member);
});

app.get('/api/bar', function(req, res, next) {
  // Only /api/bar will run this
  doSomethingDifferentWithMember(req.member);
});

त्रुटि करने वाला

त्रुटि हैंडलर हस्ताक्षर function(err, req, res, next) साथ मिडलवेयर हैं। उन्हें प्रति रूट (उदाहरण के लिए app.get('/foo', function(err, req, res, next) सेट किया जा सकता है app.get('/foo', function(err, req, res, next) लेकिन आमतौर पर, एक एरर हैंडलर जो एक एरर पेज को रेंडर करता है, पर्याप्त है।

app.get('/foo', function(req, res, next) {
  doSomethingAsync(function(err, data) {
    if (err) return next(err);
    renderPage(data);
  });
});

// In the case that doSomethingAsync return an error, this special
// error handler middleware will be called with the error as the 
// first parameter.
app.use(function(err, req, res, next) {
  renderErrorPage(err);
});

मध्यस्थ

ऊपर दिए गए प्रत्येक कार्य वास्तव में एक मिडलवेयर फ़ंक्शन है जो किसी अनुरोध पर निर्धारित रूट से मेल खाने पर चलाया जाता है, लेकिन किसी भी रूट पर किसी भी मिडलवेयर फ़ंक्शन को परिभाषित किया जा सकता है। इससे मिडलवेयर को अलग-अलग फ़ाइलों में परिभाषित किया जा सकता है और कई मार्गों पर आम तर्क का पुन: उपयोग किया जा सकता है।

app.get('/bananas', function(req, res, next) {
  getMember(function(err, member) {
    if (err) return next(err);
    // If there's no member, don't try to look
    // up data. Just go render the page now.
    if (!member) return next('route');
    // Otherwise, call the next middleware and fetch
    // the member's data.
    req.member = member;
    next();
  });
}, function(req, res, next) {
  getMemberData(req.member, function(err, data) {
    if (err) return next(err);
    // If this member has no data, don't bother
    // parsing it. Just go render the page now.
    if (!data) return next('route');
    // Otherwise, call the next middleware and parse
    // the member's data. THEN render the page.
    req.member.data = data;
    next();
  });
}, function(req, res, next) {
  req.member.parsedData = parseMemberData(req.member.data);
  next();
});

app.get('/bananas', function(req, res, next) {
  renderBananas(req.member);
});

इस उदाहरण में, प्रत्येक मिडलवेयर फ़ंक्शन या तो अपनी फ़ाइल में या फ़ाइल में किसी अन्य चर में होगा ताकि इसे अन्य मार्गों में पुन: उपयोग किया जा सके।

गलती संभालना

बेसिक डॉक्स यहां देखे जा सकते हैं

app.get('/path/:id(\\d+)', function (req, res, next) { // please note: "next" is passed
    if (req.params.id == 0) // validate param
        return next(new Error('Id is 0')); // go to first Error handler, see below

    // Catch error on sync operation
    var data;
    try {
        data = JSON.parse('/file.json');
    } catch (err) {
        return next(err);
    }

    // If some critical error then stop application
    if (!data)
        throw new Error('Smth wrong');

    // If you need send extra info to Error handler
    // then send custom error (see Appendix B)
    if (smth)
        next(new MyError('smth wrong', arg1, arg2))

    // Finish request by res.render or res.end
    res.status(200).end('OK');
});    

// Be sure: order of app.use have matter
// Error handler
app.use(function(err, req, res, next)) {
    if (smth-check, e.g. req.url != 'POST') 
        return next(err); // go-to Error handler 2.

    console.log(req.url, err.message);

    if (req.xhr) // if req via ajax then send json else render error-page
        res.json(err);
    else 
        res.render('error.html', {error: err.message});  
});

// Error handler 2
app.use(function(err, req, res, next)) {
    // do smth here e.g. check that error is MyError
    if (err instanceof MyError) {
        console.log(err.message, err.arg1, err.arg2);
    }     
    ...
    res.end();
});

परिशिष्ट A

// "In Express, 404 responses are not the result of an error, 
// so the error-handler middleware will not capture them." 
// You can change it.
app.use(function(req, res, next) {
    next(new Error(404)); 
});

परिशिष्ट बी

// How to define custom error
var util = require('util');
...
function MyError(message, arg1, arg2) {
    this.message = message;
    this.arg1 = arg1;
    this.arg2 = arg2;
    Error.captureStackTrace(this, MyError);
}
util.inherits(MyError, Error);
MyError.prototype.name = 'MyError';

हुक: किसी भी रीक से पहले और किसी भी रेस के बाद कोड को कैसे निष्पादित करें

app.use() और मिडलवेयर का उपयोग "पहले" के लिए किया जा सकता है और निकट और खत्म होने वाली घटनाओं के संयोजन का उपयोग "बाद" के लिए किया जा सकता है।

app.use(function (req, res, next) {
    function afterResponse() {
        res.removeListener('finish', afterResponse);
        res.removeListener('close', afterResponse);

        // actions after response
    }
    res.on('finish', afterResponse);
    res.on('close', afterResponse);

    // action before request
    // eventually calling `next()`
    next();
});
...
app.use(app.router);

इसका एक उदाहरण लकड़हारा मिडलवेयर है, जो डिफ़ॉल्ट रूप से प्रतिक्रिया के बाद लॉग में संलग्न होगा।

बस यह सुनिश्चित करें कि इस "मिडलवेयर" का उपयोग app.router से पहले किया जाता है क्योंकि ऑर्डर मायने रखता है।

---

मूल पोस्ट यहाँ है

POST अनुरोधों को संभालना

जैसे आप हैंडल को ऐप के साथ एक्सप्रेस में अनुरोध प्राप्त करते हैं। पद्धति, आप पोस्ट अनुरोधों को संभालने के लिए ऐप। पोस्ट विधि का उपयोग कर सकते हैं।

लेकिन इससे पहले कि आप पोस्ट अनुरोधों को संभाल सकें, आपको body-parser मिडलवेयर का उपयोग करना होगा। यह केवल POST , PUT , DELETE और अन्य अनुरोधों के मुख्य भाग को पार्स करता है।

Body-Parser मिडलवेयर अनुरोध के शरीर को पार्स करता है और इसे req.body में उपलब्ध ऑब्जेक्ट में req.body

var bodyParser = require('body-parser');

const express = require('express');

const app = express();

// Parses the body for POST, PUT, DELETE, etc.
app.use(bodyParser.json());

app.use(bodyParser.urlencoded({ extended: true }));

app.post('/post-data-here', function(req, res, next){

    console.log(req.body); // req.body contains the parsed body of the request.

});

app.listen(8080, 'localhost');

कुकी-पार्सर के साथ कुकीज़ सेट करना

कुकी-पार्सर मॉड्यूल का उपयोग करके कुकीज़ को स्थापित करने और पढ़ने के लिए एक उदाहरण निम्नलिखित है:

var express = require('express');
var cookieParser = require('cookie-parser'); // module for parsing cookies
var app = express();
app.use(cookieParser());

app.get('/setcookie', function(req, res){
    // setting cookies
    res.cookie('username', 'john doe', { maxAge: 900000, httpOnly: true });
    return res.send('Cookie has been set');
});

app.get('/getcookie', function(req, res) {
    var username = req.cookies['username'];
    if (username) {
        return res.send(username);        
    }

    return res.send('No cookie found');
});

app.listen(3000);

एक्सप्रेस में कस्टम मिडलवेयर

एक्सप्रेस में, आप उन बिचौलियों को परिभाषित कर सकते हैं जिनका उपयोग अनुरोधों की जांच करने या प्रतिक्रिया में कुछ हेडर सेट करने के लिए किया जा सकता है।

app.use(function(req, res, next){ });    // signature

उदाहरण

निम्न कोड user को अनुरोध ऑब्जेक्ट में जोड़ता है और अगले मिलान मार्ग पर नियंत्रण पास करता है।

var express = require('express');
var app = express();

//each request will pass through it
app.use(function(req, res, next){
    req.user = 'testuser';
    next();    // it will pass the control to next matching route
});

app.get('/', function(req, res){
    var user = req.user;
    console.log(user); // testuser
    return res.send(user);
});

app.listen(3000);

एक्सप्रेस में त्रुटि से निपटने

एक्सप्रेस में, आप अनुप्रयोग में होने वाली त्रुटियों से निपटने के लिए एकीकृत त्रुटि हैंडलर को परिभाषित कर सकते हैं। फिर सभी मार्गों और लॉजिक कोड के अंत में हैंडलर को परिभाषित करें।

उदाहरण

var express = require('express');
var app = express();

//GET /names/john
app.get('/names/:name', function(req, res, next){
    if (req.params.name == 'john'){
        return res.send('Valid Name');
    } else{
        next(new Error('Not valid name'));    //pass to error handler
    }
});

//error handler
app.use(function(err, req, res, next){
    console.log(err.stack);    // e.g., Not valid name
    return res.status(500).send('Internal Server Occured');
});

app.listen(3000);

मिडिलवेयर जोड़ना

मिडलवेयर फ़ंक्शंस ऐसे फ़ंक्शंस हैं जिनमें एक्सेस ऑब्जेक्ट (req), रेस्पॉन्स ऑब्जेक्ट (रेस), और एप्लिकेशन के रिक्वेस्ट-रिस्पॉन्स साइकल में अगला मिडलवेयर फ़ंक्शन होता है।

Middleware कार्यों किसी भी कोड निष्पादित, में परिवर्तन कर सकते res और req वस्तुओं, अंत प्रतिक्रिया चक्र और अगले मिडलवेयर कहते हैं।

मिडलवेयर का बहुत सामान्य उदाहरण cors मॉड्यूल है। CORS समर्थन जोड़ने के लिए, बस इसे स्थापित करें, इसकी आवश्यकता है और इस लाइन को डालें:

app.use(cors());

किसी भी राउटर या रूटिंग कार्यों से पहले।

नमस्ते दुनिया

यहां हम एक्सप्रेस का उपयोग करके एक बुनियादी हैलो वर्ल्ड सर्वर बनाते हैं। मार्ग:

• '/'
• '/ विकी'

और आराम के लिए "404" देगा, अर्थात पृष्ठ नहीं मिला।

'use strict';

const port = process.env.PORT || 3000;

var app = require('express')();
    app.listen(port);

app.get('/',(req,res)=>res.send('HelloWorld!'));
app.get('/wiki',(req,res)=>res.send('This is wiki page.'));
app.use((req,res)=>res.send('404-PageNotFound'));

नोट: हमने एक्सप्रेस मार्ग के अंतिम मार्ग के रूप में 404 मार्ग को क्रम में रखा है और क्रमबद्ध रूप से प्रत्येक अनुरोध के लिए उन्हें संसाधित किया है।