ExpressJS पर एक पूर्ण MVC वेबसाइट का निर्माण

NB: यह सामग्री उन लोगों के लिए है, जिन्होंने पहले से ही नोड.जेएस के सैद्धांतिक आधार से खुद को परिचित कर लिया है और चाहते हैं, जैसा कि वे कहते हैं, बल्ले से सही - जल्द से जल्द इस उपकरण का उपयोग करके विकास में डुबकी लगाने के लिए। कोई कटौती नहीं, केवल कोडिंग। यदि दिलचस्पी है, तो शर्मीली मत बनो, हम बिल्ली के नीचे से गुजरते हैं।


एक अनुवादक से: मैं खुद ही हाल ही में नोड.जेएस सीखना शुरू किया। निस्संदेह, इंटरनेट पर शुरुआती के लिए कई अच्छे (!) मैनुअल हैं, विशेष रूप से यहां हब पर (उदाहरण के लिए, यहां और यहां )। हालाँकि, लेखक कसीमोइर त्सोनेव का यह मैनुअल (मैं आपको उनके बहु-विषय ब्लॉग को देखने की सलाह भी देता हूं) मुझे विशेष रूप से उल्लेखनीय लग रहा था, क्योंकि एक उचित रूप से संक्षिप्त और समझने योग्य रूप में यह एमवीसी पैटर्न और बेस का उपयोग करके एक्सप्रेस मॉड्यूल पर आधारित एक पूर्ण-विकसित नोड.जेएस एप्लिकेशन के निर्माण की प्रक्रिया का वर्णन करता है। MongoDB डेटा। लेखक परीक्षण जैसी महत्वपूर्ण चीज पर भी ध्यान देता है।

अनुवाद

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

प्रविष्टि

एक्सप्रेस सर्वश्रेष्ठ नोड फ्रेमवर्क में से एक है। इसमें उत्कृष्ट डेवलपर सहायता और उपयोगी सुविधाओं का एक समूह है। एक्सप्रेस पर कई महान लेख हैं जो इसके साथ काम करने की सभी मूल बातें कवर करते हैं। हालांकि, अब मैं थोड़ी गहराई में खुदाई करना चाहता हूं और एक पूर्ण वेबसाइट बनाने में अपने अनुभव को साझा करना चाहता हूं। सामान्य तौर पर, यह लेख न केवल एक्सप्रेस के बारे में है, बल्कि अन्य के साथ इसके संयोजन के बारे में भी है, कोई कम अद्भुत उपकरण जो डेवलपर्स के लिए उपलब्ध नहीं हैं।
मेरा मानना ​​है कि आप Node.js से परिचित हैं, इसे अपने सिस्टम पर स्थापित किया है, और आपने पहले ही इस पर कुछ एप्लिकेशन बना लिए हैं।
एक्सप्रेस फ्रेम कनेक्ट पर आधारित है। यह मिडलवेयर फ़ंक्शंस का एक सेट है जो कई उपयोगी चीज़ों के साथ आता है। यदि आप रुचि रखते हैं कि एक मिडलवेयर फ़ंक्शन क्या है, तो इसका एक छोटा उदाहरण है:

var connect = require('connect'), http = require('http'); var app = connect() .use(function(req, res, next) { console.log("That's my first middleware"); next(); }) .use(function(req, res, next) { console.log("That's my second middleware"); next(); }) .use(function(req, res, next) { console.log("end"); res.end("hello world"); }); http.createServer(app).listen(3000); 

मिडलवेयर फ़ंक्शन मूल रूप से एक फ़ंक्शन है जो अनुरोधों को स्वीकार करता है और ऑब्जेक्ट्स को पैरामीटर के रूप में स्वीकार करता है, साथ ही एक कॉलबैक फ़ंक्शन भी कहा जाता है जिसे अगले कहा जाएगा। प्रत्येक मिडलवेयर फ़ंक्शन तय करता है: या तो एक रिस्पांस ऑब्जेक्ट का उपयोग करके प्रतिक्रिया करें, या अगले कॉलबैक फ़ंक्शन में स्ट्रीम पास करें। उपरोक्त उदाहरण में, यदि आप दूसरे फ़ंक्शन में अगली () विधि कॉल को हटाते हैं, तो स्ट्रिंग "हैलो वर्ल्ड" क्लाइंट को कभी नहीं भेजा जाएगा। सामान्य तौर पर, यह एक्सप्रेस कैसे काम करता है। इसमें कई पूर्वनिर्धारित मिडलवेयर फ़ंक्शन हैं जो निस्संदेह आपको एक टन समय बचाएंगे। उदाहरण के लिए, एक बॉडी पार्सर है जो अनुरोध निकाय को पार्स करता है और सामग्री प्रकार के एप्लिकेशन / जसन , एप्लिकेशन / x-www-form-urlencoded और मल्टीपार्ट / फॉर्म-डेटा का समर्थन करता है । या कुकी पार्सर जो कुकी हेडर को पार्स करता है और एक ऑब्जेक्ट के साथ req.cookies फ़ील्ड को पॉप्युलेट करता है जिसकी कुंजी कुकी का नाम है।
वास्तव में, एक्सप्रेस खुद को कनेक्ट फ्रेम में लपेटता है, इसे कुछ कार्यक्षमता के साथ पूरक करता है, जैसे कि, उदाहरण के लिए, तर्क को पार करना, जो रूटिंग प्रक्रिया के माध्यम से चिकनी हो जाता है। निम्नलिखित GET अनुरोध संसाधित करने का एक उदाहरण है:

 app.get('/hello.txt', function(req, res){ var body = 'Hello World'; res.setHeader('Content-Type', 'text/plain'); res.setHeader('Content-Length', body.length); res.end(body); }); 

स्थापना

एक्सप्रेस स्थापित करने के लिए दो विकल्प हैं। पहला यह है कि पैकेज.जॉन फ़ाइल में अपना विवरण रखें और एनपीएम इंस्टॉलेशन कमांड को निष्पादित करें (ऐसा मज़ाक है कि इस पैकेज मैनेजर का नाम "कोई समस्या नहीं है" :) के लिए है)।

 { "name": "MyWebSite", "description": "My website", "version": "0.0.1", "dependencies": { "express": "3.x" } } 

फ्रेमवर्क कोड को नोड_मॉडल्स डायरेक्टरी में रखा जाएगा और आपके पास इसका एक उदाहरण बनाने का अवसर होगा। मैं एक विकल्प पसंद करता हूं: कमांड लाइन। बस npm स्थापित -g एक्सप्रेस चलाकर एक्सप्रेस स्थापित करें । ऐसा करने से, आपके पास एक नया सीएलआई उपकरण होगा। उदाहरण के लिए, यदि आप करते हैं:

 express --sessions --css less --hogan app 

एक्सप्रेस आपके लिए एक कॉन्फ़िगर एप्लीकेशन फ्रेमवर्क उत्पन्न करेगा। निम्नलिखित एक्सप्रेस की सूची है (1) कमांड विकल्प:

 Usage: express [options] Options: -h, --help output usage information -V, --version output the version number -s, --sessions add session support -e, --ejs add ejs engine support (defaults to jade) -J, --jshtml add jshtml engine support (defaults to jade) -H, --hogan add hogan.js engine support -c, --css add stylesheet support (less|stylus) (defaults to plain css) -f, --force force on non-empty directory 

जैसा कि आप देख सकते हैं, उपलब्ध विकल्पों की सूची छोटी है, लेकिन मेरे लिए यह पर्याप्त है। आमतौर पर, मैं सीएसएस प्रीप्रोसेसर के साथ-साथ होगन टेम्पलेट इंजन के रूप में कम पुस्तकालय का उपयोग करता हूं। हमारे उदाहरण में, हमें सत्र समर्थन की आवश्यकता है, और - सत्र विकल्प इस समस्या को हल करेगा। जब टीम पूरी हो जाएगी, तो हमारी परियोजना की संरचना इस तरह दिखाई देगी:

 /public /images /javascripts /stylesheets /routes /index.js /user.js /views /index.hjs /app.js /package.json 

यदि आप package.json फ़ाइल को देखते हैं, तो आप देखेंगे कि हमारे द्वारा आवश्यक सभी निर्भरताएँ यहाँ जोड़ी गई हैं। लेकिन वे अभी तक स्थापित नहीं हैं। ऐसा करने के लिए, बस npm इंस्टॉल कमांड को चलाएं , जिसके बाद नोड_मॉड्यूल्स डायरेक्टरी दिखाई देती है ।
मैं समझता हूं कि ऊपर वर्णित दृष्टिकोण सार्वभौमिक कहलाने के योग्य नहीं है। उदाहरण के लिए, आपको मार्ग संचालकों को एक अलग निर्देशिका में रखने की आवश्यकता हो सकती है, या कुछ और। लेकिन, जैसा कि अगले कुछ अध्यायों में दिखाया जाएगा, मैं उत्पन्न संरचना में बदलाव करूंगा, जो बहुत सरल है। इसके आधार पर, मैं आपको एक्सप्रेस जनरेटर के रूप में एक्सप्रेस (1) कमांड का उपयोग करने की सलाह देता हूं।

FastDelivery

इस ट्यूटोरियल के लिए, मैंने FastDelivery नामक एक काल्पनिक कंपनी के लिए एक सरल वेबसाइट बनाई। यहाँ तैयार डिजाइन का एक स्क्रीनशॉट है:


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

 /public /images (there are several images exported from Photoshop) /javascripts /stylesheets /home.less /inner.less /style.css /style.less (imports home.less and inner.less) /routes /index.js /views /index.hjs (home page) /inner.hjs (template for every other page of the site) /app.js /package.json 

यहां उन साइट तत्वों की एक सूची दी गई है जिन्हें हम प्रशासित कर पाएंगे:

• मुखपृष्ठ (केंद्र में बैनर - शीर्षक और पाठ)
• ब्लॉग (लेख जोड़ें, निकालें और संपादित करें)
• सेवा पृष्ठ
• खदान पृष्ठ (पेशेवर विकास, रेत का गड्ढा नहीं :))
• संपर्क पृष्ठ

विन्यास

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

 var config = { local: { mode: 'local', port: 3000 }, staging: { mode: 'staging', port: 4000 }, production: { mode: 'production', port: 5000 } } module.exports = function(mode) { return config[mode || process.argv[2] || 'local'] || config.local; } 

फिलहाल, हमारे पास केवल दो पैरामीटर हैं - मोड (मोड) और पोर्ट (पोर्ट)। जैसा कि आपने अनुमान लगाया होगा, एप्लिकेशन विभिन्न सर्वरों पर अलग-अलग पोर्ट का उपयोग करता है। इसलिए हमें app.js फ़ाइल में अपनी साइट के प्रवेश बिंदु को अपडेट करना चाहिए।

 ... var config = require('./config')(); ... http.createServer(app).listen(config.port, function(){ console.log('Express server listening on port ' + config.port); }); 

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

 node app.js staging 

उत्पादन होगा:

 Express server listening on port 4000 

अब हमारी सभी सेटिंग्स एक ही स्थान पर संग्रहीत हैं, उन्हें प्रबंधित करना आसान है।

परीक्षण

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

 npm install -g jasmine-node 

चलो हमारे परीक्षणों को संग्रहीत करने के लिए एक निर्देशिका बनाएं। पहली चीज जो हम परीक्षण करेंगे वह हमारी कॉन्फ़िगरेशन फ़ाइल है। परीक्षण फ़ाइलों के नाम .spec.js के साथ समाप्त होने चाहिए, इसलिए हम फ़ाइल को config.spec.js कहेंगे।

 describe("Configuration setup", function() { it("should load local configurations", function(next) { var config = require('../config')(); expect(config.mode).toBe('local'); next(); }); it("should load staging configurations", function(next) { var config = require('../config')('staging'); expect(config.mode).toBe('staging'); next(); }); it("should load production configurations", function(next) { var config = require('../config')('production'); expect(config.mode).toBe('production'); next(); }); }); 

चमेली-नोड / .tests कमांड चलाएँ और आप निम्नलिखित देखेंगे:

 Finished in 0.008 seconds 3 tests, 6 assertions, 0 failures, 0 skipped 

अब मैंने कार्यान्वयन को पहले लिखा, और उसके बाद ही परीक्षण। यह एक टीडीडी दृष्टिकोण नहीं है, लेकिन निम्नलिखित अध्यायों में मैं इसके विपरीत करूंगा।

मैं अत्यधिक समय पर्याप्त परीक्षण लिखने की सलाह देता हूं। पूरी तरह से परीक्षण से आच्छादित आवेदन से बेहतर कुछ नहीं है।
कुछ साल पहले, मुझे कुछ बहुत महत्वपूर्ण एहसास हुआ, कुछ ऐसा जो आपको बेहतर एप्लिकेशन बनाने में मदद कर सकता है। हर बार जब आप एक नया वर्ग, एक नया मॉड्यूल या तर्क का एक टुकड़ा लिखना शुरू करते हैं, तो अपने आप से पूछें:

मैं इसका परीक्षण कैसे कर सकता हूं?

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

डेटाबेस

यदि हम एक गतिशील वेबसाइट का निर्माण कर रहे हैं, तो हमें इसमें जानकारी संग्रहीत करने के लिए एक डेटाबेस की आवश्यकता है। इसके लिए मैंने इस निर्देश के लिए मोंगोडब को चुना। Mongo एक NoSQL डेटाबेस है। आपको यहां इंस्टॉलेशन निर्देश मिलेंगे, और जब से मैं विंडोज उपयोगकर्ता हूं, मैंने विंडोज के लिए इंस्टॉलेशन निर्देशों का पालन किया है । आपके द्वारा इंस्टॉलेशन समाप्त करने के बाद, MongoDB डेमन शुरू करें, जो डिफ़ॉल्ट रूप से पोर्ट 27017 पर सुनता है। इसलिए, सिद्धांत रूप में, हमारे पास इस पोर्ट से कनेक्ट करने और मैन्गोडब सर्वर के साथ संदेशों का आदान-प्रदान करने का अवसर है। नोड स्क्रिप्ट के माध्यम से ऐसा करने के लिए, हमें एक मोंगोडब मॉड्यूल / ड्राइवर की आवश्यकता होती है। यदि आपने इस निर्देश के लिए स्रोत फ़ाइलों को डाउनलोड किया है, तो मॉड्यूल को पहले ही पैकेज.जॉन फ़ाइल में जोड़ दिया गया है। यदि नहीं, तो बस "mongodb" जोड़ें: "1.3.10" निर्भरता संपत्ति के लिए और npm स्थापित कमांड चलाते हैं। अगला, हम एक परीक्षण लिखेंगे जो यह जांच करेगा कि मोंगोडब सर्वर चल रहा है या नहीं।

फ़ाइल /tests/mongodb.spec.js:

 describe("MongoDB", function() { it("is there a server running", function(next) { var MongoClient = require('mongodb').MongoClient; MongoClient.connect('mongodb://127.0.0.1:27017/fastdelivery', function(err, db) { expect(err).toBe(null); next(); }); }); }); 

मोंगॉडब क्लाइंट विधि में कॉलबैक फ़ंक्शन .connect एक db ऑब्जेक्ट प्राप्त करता है। बाद में हम इसका उपयोग अपने डेटा को प्रबंधित करने के लिए करते हैं। इसका मतलब है कि हमें अपने मॉडल के अंदर इसकी आवश्यकता है। डेटाबेस से क्वेरी करने पर हर बार एक नया MongoClient ऑब्जेक्ट बनाना एक अच्छा विचार नहीं होगा। यही कारण है कि मैंने डेटाबेस से कनेक्ट करने के कॉलबैक फ़ंक्शन के लिए एक्सप्रेस सर्वर के लॉन्च को स्थानांतरित कर दिया:

 MongoClient.connect('mongodb://127.0.0.1:27017/fastdelivery', function(err, db) { if(err) { console.log('Sorry, there is no mongo db server running.'); } else { var attachDB = function(req, res, next) { req.db = db; next(); }; http.createServer(app).listen(config.port, function(){ console.log('Express server listening on port ' + config.port); }); } }); 

चूंकि हमारे पास एक पर्यावरण कॉन्फ़िगरेशन सेटिंग्स फ़ाइल है, इसलिए यहां मोंगोडब सर्वर के होस्ट नाम और पोर्ट को रखना और कनेक्शन URL को बदलना एक अच्छा विचार होगा:

'मोंगोडब: //' + config.mongo.host + ':' + config.mongo.port + '/ fastpelija'

मिडिलवेयर फ़ंक्शन अटैचमेंट पर विशेष ध्यान दें , जिसे मैंने http.createServer फ़ंक्शन पर कॉल करने से ठीक पहले जोड़ा था। इस छोटे से अतिरिक्त के लिए धन्यवाद, हम अनुरोध ऑब्जेक्ट की .db संपत्ति को भर देंगे। अच्छी खबर यह है कि हम मार्ग निर्धारण के दौरान कई कार्य करने में सक्षम होंगे। उदाहरण के लिए:

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

इस प्रकार, एक्सप्रेस अनुलग्नक फ़ंक्शन को अग्रिम में कॉल करता है ताकि यह हमारे मार्ग हैंडलर में हो जाए। जब ऐसा होता है, तो अनुरोध ऑब्जेक्ट में एक .db गुण होगा और हम इसका उपयोग डेटाबेस तक पहुंचने के लिए कर सकते हैं।

MVC

हम सभी एमवीसी पैटर्न से परिचित हैं। सवाल यह है कि इसे एक्सप्रेस में कैसे लागू किया जाए। एक तरीका या दूसरा, यह व्याख्या का विषय है। अगले कुछ अध्यायों में, मैं ऐसे मॉड्यूल बनाऊंगा जो एक मॉडल, दृश्य और नियंत्रक के रूप में काम करेंगे।

आदर्श

एक मॉडल वह है जो हमारे एप्लिकेशन के डेटा को प्रोसेस करेगा। यह MongoClient ऑब्जेक्ट द्वारा लौटाए गए db ऑब्जेक्ट तक पहुँच होना चाहिए। हमारे मॉडल में इसे विस्तारित करने की विधि भी होनी चाहिए, क्योंकि हमें विभिन्न प्रकार के मॉडल की आवश्यकता हो सकती है। उदाहरण के लिए, हम एक BlogModel या ContactsModel मॉडल बनाना चाहते हैं। ऐसा करने के लिए, हमें पहले एक परीक्षण बनाना होगा: /tests/base.model.spec.js । और याद रखें: इन परीक्षणों को बनाकर, हम गारंटी दे सकते हैं कि हमारे मॉडल केवल वही करेंगे जो हम चाहते हैं, और कुछ नहीं।

 var Model = require("../models/Base"), dbMockup = {}; describe("Models", function() { it("should create a new model", function(next) { var model = new Model(dbMockup); expect(model.db).toBeDefined(); expect(model.extend).toBeDefined(); next(); }); it("should be extendable", function(next) { var model = new Model(dbMockup); var OtherTypeOfModel = model.extend({ myCustomModelMethod: function() { } }); var model2 = new OtherTypeOfModel(dbMockup); expect(model2.db).toBeDefined(); expect(model2.myCustomModelMethod).toBeDefined(); next(); }) }); 

एक वास्तविक db ऑब्जेक्ट के बजाय, मैंने एक मॉक ऑब्जेक्ट पास करने का निर्णय लिया। यह मामले के लिए किया जाता है यदि बाद में मैं कुछ विशिष्ट परीक्षण करना चाहता हूं, जो डेटाबेस से आने वाले डेटा पर निर्भर करेगा। इस डेटा को मैन्युअल रूप से परिभाषित करना बहुत आसान होगा।
एक विधि विस्तार को लागू करना एक चुनौती है, क्योंकि हमें प्रोटोटाइप मॉड्यूल.एक्सपोर्ट को बदलने की आवश्यकता है, लेकिन मूल कंस्ट्रक्टर को बरकरार रखें। सौभाग्य से, हमने पहले से ही एक परीक्षण लिखा है जो हमारे कोड के प्रदर्शन की जांच करता है। ऊपर कोड स्निपेट का संस्करण इस तरह दिखता है:

 module.exports = function(db) { this.db = db; }; module.exports.prototype = { extend: function(properties) { var Child = module.exports; Child.prototype = module.exports.prototype; for(var key in properties) { Child.prototype[key] = properties[key]; } return Child; }, setDB: function(db) { this.db = db; }, collection: function() { if(this._collection) return this._collection; return this._collection = this.db.collection('fastdelivery-content'); } } 

दो सहायक विधियों को यहां परिभाषित किया गया है। हमारे डेटाबेस से संग्रह के लिए डीबी ऑब्जेक्ट और गेट्टर के लिए सेटर।

विचार

दृश्य स्क्रीन पर जानकारी प्रदर्शित करेगा। सरल शब्दों में, एक दृश्य एक वर्ग है जो ब्राउज़र को एक प्रतिक्रिया भेजता है। एक्सप्रेस ऐसा करने का एक सरल तरीका प्रदान करता है:

 res.render('index', { title: 'Express' }); 

एक प्रतिक्रिया वस्तु एक आवरण है जिसमें एक अच्छा एपीआई है जो हमारे जीवन को आसान बनाता है। हालांकि, मैं अपना स्वयं का मॉड्यूल बनाना पसंद करता हूं, जिसे इसकी कार्यक्षमता में रोल किया जाएगा। विचारों की मानक निर्देशिका को टेम्प्लेट द्वारा प्रतिस्थापित किया जाएगा, और विचारों की पुरानी निर्देशिका हमें बेस व्यू क्लास देगी।
इस छोटे से बदलाव के लिए अब एक और बदलाव की आवश्यकता है। हमें यह सूचित करना चाहिए कि हमारी टेम्पलेट फाइलें अब एक अलग निर्देशिका में हैं:

 app.set('views', __dirname + '/templates'); 

सबसे पहले, मैं वह सब कुछ निर्धारित करूंगा जिसकी मुझे आवश्यकता है, मैं परीक्षण लिखूंगा, और उसके बाद मैं कार्यान्वयन शुरू करूंगा। हमें एक मॉड्यूल की आवश्यकता है जो निम्नलिखित आवश्यकताओं को पूरा करता है:

• इसके निर्माता को एक प्रतिक्रिया ऑब्जेक्ट और टेम्पलेट नाम प्राप्त करना चाहिए
• इसमें एक टेम्पलेट आउटपुट विधि होनी चाहिए जो डेटा ऑब्जेक्ट को स्वीकार करती है
• यह एक्स्टेंसिबल होना चाहिए।

आप आश्चर्यचकित हो सकते हैं: मुझे प्रस्तुति वर्ग का विस्तार करने की आवश्यकता क्यों थी? क्या वह सिर्फ response.render विधि नहीं कहता है? खैर, व्यवहार में, ऐसे समय होते हैं जब आपको एक अलग हेडर भेजने या प्रतिक्रिया ऑब्जेक्ट में हेरफेर करने की आवश्यकता होती है। उदाहरण के लिए, JSON में आए प्रोसेस डेटा:

 var data = {"developer": "Krasimir Tsonev"}; response.contentType('application/json'); response.send(JSON.stringify(data)); 

हर बार ऐसा करने के बजाय, HTMLView और JSONView क्लासेस का होना बहुत अच्छा होगा। या XML डेटा को ब्राउज़र में XML डेटा भेजने के लिए वर्ग। यदि आप एक बड़ा वेब एप्लिकेशन बनाते हैं तो यह बेहतर होगा, यदि आप एक ही कोड को बार-बार कॉपी और पेस्ट करते हैं तो ऐसी कार्यक्षमता पहले से ही लागू होगी।
निम्नलिखित / साक्षात्कार / Base.js वर्ग के लिए एक परीक्षा है:

 var View = require("../views/Base"); describe("Base view", function() { it("create and render new view", function(next) { var responseMockup = { render: function(template, data) { expect(data.myProperty).toBe('value'); expect(template).toBe('template-file'); next(); } } var v = new View(responseMockup, 'template-file'); v.render({myProperty: 'value'}); }); it("should be extendable", function(next) { var v = new View(); var OtherView = v.extend({ render: function(data) { expect(data.prop).toBe('yes'); next(); } }); var otherViewInstance = new OtherView(); expect(otherViewInstance.render).toBeDefined(); otherViewInstance.render({prop: 'yes'}); }); }); 

रेंडरिंग (दृश्य) का परीक्षण करने के लिए, मुझे एक लेआउट बनाना था। इस मामले के लिए, परीक्षण के पहले भाग में, मैंने एक ऑब्जेक्ट बनाया जो एक्सप्रेस फ्रेमवर्क की प्रतिक्रिया वस्तु का अनुकरण करता है। परीक्षण के दूसरे भाग में, मैंने एक और व्यू क्लास बनाया, जो बेस क्लास को इनहेरिट करता है और अपनी रेंडरिंग विधि का उपयोग करता है।
कक्षा कोड / साक्षात्कार / Base.js :

 module.exports = function(response, template) { this.response = response; this.template = template; }; module.exports.prototype = { extend: function(properties) { var Child = module.exports; Child.prototype = module.exports.prototype; for(var key in properties) { Child.prototype[key] = properties[key]; } return Child; }, render: function(data) { if(this.response && this.template) { this.response.render(this.template, data); } } } 

अब हमारे पास परीक्षण के लिए हमारी निर्देशिका में तीन परीक्षण हैं, और यदि आप चमेली-नोड / .tests कमांड चलाते हैं , तो परिणाम निम्नानुसार होना चाहिए:

 Finished in 0.009 seconds 7 tests, 18 assertions, 0 failures, 0 skipped 

नियंत्रक

याद रखें, हमने मार्गों के बारे में बात की थी, और वे कैसे निर्धारित किए गए थे?

 app.get('/', routes.index); 

ऊपर के उदाहरण में मार्ग के बाद का प्रतीक '/' नियंत्रक है। यह मिडलवेयर फ़ंक्शन है जो अनुरोध , प्रतिक्रिया और कॉलबैक फ़ंक्शन अगले () में लेता है।

 exports.index = function(req, res, next) { res.render('index', { title: 'Express' }); }; 

उपरोक्त वर्णन करता है कि एक्सप्रेस का उपयोग करने के संदर्भ में आपका नियंत्रक कैसा दिखना चाहिए। एक्सप्रेस (1) कमांड नाम मार्गों के तहत एक निर्देशिका बनाता है, लेकिन हमारे मामले में इसे नियंत्रक कहा जाता है तो बेहतर होगा। मैंने इसका नाम बदल दिया ताकि फ़ाइल संरचना इस पैटर्न से मेल खाए।
चूंकि हम केवल एक छोटे से छोटे अनुप्रयोग से अधिक निर्माण कर रहे हैं, इसलिए आधार वर्ग बनाना उचित होगा जिसे बढ़ाया जा सकता है। अगर हमें कभी भी अपने सभी नियंत्रकों के लिए कार्यक्षमता जोड़ने की आवश्यकता है, तो यह आधार वर्ग ऐड-ऑन को लागू करने के लिए सही जगह होगी। फिर से, मैं पहले एक परीक्षण लिख रहा हूं, तो चलो परिभाषित करें कि हमें आधार वर्ग के लिए क्या चाहिए:

• इसमें एक एक्स्टेंसिबल तरीका होना चाहिए जो एक ऑब्जेक्ट लेता है और एक नया बच्चा उदाहरण देता है
• बच्चे के उदाहरण के लिए एक रन विधि होनी चाहिए, जो कि पुराना पुराना मिडलवेयर फंक्शन है
• एक नाम संपत्ति होनी चाहिए जो नियंत्रक को पहचानती है
• हमें आधार वर्ग से विरासत में मिली स्वतंत्र वस्तुएँ बनाने में सक्षम होना चाहिए।

बस कुछ बिंदु, लेकिन हम बाद में अधिक कार्यक्षमता जोड़ सकते हैं।
परीक्षा कुछ इस तरह दिखाई देगी:

 var BaseController = require("../controllers/Base"); describe("Base controller", function() { it("should have a method extend which returns a child instance", function(next) { expect(BaseController.extend).toBeDefined(); var child = BaseController.extend({ name: "my child controller" }); expect(child.run).toBeDefined(); expect(child.name).toBe("my child controller"); next(); }); it("should be able to create different childs", function(next) { var childA = BaseController.extend({ name: "child A", customProperty: 'value' }); var childB = BaseController.extend({ name: "child B" }); expect(childA.name).not.toBe(childB.name); expect(childB.customProperty).not.toBeDefined(); next(); }); }); 

और नीचे /controllers/Base.js का कार्यान्वयन है:

 var _ = require("underscore"); module.exports = { name: "base", extend: function(child) { return _.extend({}, this, child); }, run: function(req, res, next) { } } 

बेशक, प्रत्येक वंशज वर्ग के पास अपना स्वयं का रन तरीका होना चाहिए जो अपने स्वयं के तर्क को लागू करता है।

FastDelivery वेबसाइट

ठीक है, हमारे पास हमारे एमवीसी वास्तुकला के लिए कक्षाओं का एक अच्छा सेट है, और हमने सभी मॉड्यूल को परीक्षणों के साथ कवर किया है। अब हम अपनी काल्पनिक कंपनी FastDelivery के लिए साइट के साथ सौदा जारी रखने के लिए तैयार हैं। आइए कल्पना करें कि साइट में दो भाग होंगे - उपयोगकर्ता भाग और प्रशासन पैनल। उपयोगकर्ता भाग को अंतिम उपयोगकर्ता के लिए डेटाबेस में संग्रहीत जानकारी की प्रस्तुति के लिए अभिप्रेत किया जाएगा। प्रशासन पैनल इस जानकारी के प्रबंधन के लिए होगा। चलो आखिरी के साथ शुरू करते हैं।

नियंत्रण कक्ष

आइए सबसे पहले एक साधारण कंट्रोलर बनाएं जो एडमिन पैनल पेज पर काम करेगा।
फ़ाइल / नियंत्रक / विज्ञापन प्रबंधक :

 var BaseController = require("./Base"), View = require("../views/Base"); module.exports = BaseController.extend({ name: "Admin", run: function(req, res, next) { var v = new View(res, 'admin'); v.render({ title: 'Administration', content: 'Welcome to the control panel' }); } }); 

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

 <!DOCTYPE html> <html> <head> <title>{{ title }}</title> <link rel='stylesheet' href='/stylesheets/style.css' /> </head> <body> <div class="container"> <h1>{{ content }}</h1> </div> </body> </html> 

(इस निर्देश को छोटा और पढ़ने में आसान बनाने के लिए, मैंने यहां प्रत्येक टेम्पलेट के लिए कोड प्रदान नहीं किया है। मैं अत्यधिक अनुशंसा करता हूं कि आप GitHub से स्रोत कोड डाउनलोड करें ।)
अब, हमारे नियंत्रक को दृश्यमान बनाने के लिए, हमें ऐप में एक मार्ग जोड़ना होगा। .js :

 var Admin = require('./controllers/Admin'); ... var attachDB = function(req, res, next) { req.db = db; next(); }; ... app.all('/admin*', attachDB, function(req, res, next) { Admin.run(req, res, next); }); 

ध्यान रखें कि हम Admin.run पद्धति को सीधे मिडलवेयर फ़ंक्शन के रूप में नहीं भेजते हैं। ऐसा इसलिए है क्योंकि हम संदर्भ रखना चाहते हैं। यदि हम ऐसा करते हैं:

 app.all('/admin*', Admin.run); 

के शब्द इस वस्तु में व्यवस्थापक एक पूरी तरह से अलग जगह को इंगित करेंगे।

व्यवस्थापक पैनल संरक्षण

प्रत्येक पृष्ठ जो / व्यवस्थापक से शुरू होता है, उसे संरक्षित किया जाना चाहिए इसे प्राप्त करने के लिए, हम सत्र में निर्मित एक्सप्रेस मिडलवेयर फ़ंक्शन का उपयोग करेंगे । यह केवल सत्र नामक अनुरोध के लिए एक ऑब्जेक्ट जोड़ता है । अब हमें अपने व्यवस्थापक नियंत्रक को बदलने की आवश्यकता है ताकि यह निम्नलिखित दो काम करे:

• यदि सत्र उपलब्ध है तो उसे जांचना चाहिए। यदि नहीं, तो प्राधिकरण फ़ॉर्म प्रदर्शित करें
• यह प्राधिकरण फॉर्म से भेजे गए डेटा को स्वीकार करना चाहिए और उपयोगकर्ता को अधिकृत करेगा यदि उपयोगकर्ता नाम और पासवर्ड डेटाबेस से उपयोगकर्ता नाम और पासवर्ड से मेल खाते हैं

निम्नलिखित एक छोटा सहायक कार्य है जो ऊपर वर्णित आवश्यकताओं को पूरा करेगा:

 authorize: function(req) { return ( req.session && req.session.fastdelivery && req.session.fastdelivery === true ) || ( req.body && req.body.username === this.username && req.body.password === this.password ); } 

सबसे पहले, एक स्क्रिप्ट निष्पादित होती है जो सत्र ऑब्जेक्ट के माध्यम से उपयोगकर्ता को पहचानने की कोशिश करती है । फिर हम जांचते हैं कि फॉर्म से डेटा हमें भेजा गया है या नहीं। यदि हां, तो फॉर्म का डेटा हमें request.body ऑब्जेक्ट से उपलब्ध है , जिसे मिडलवेयर फ़ंक्शन बॉडीपार ने हमारे लिए तैयार किया है । फिर हम केवल यह देखने के लिए जाँचते हैं कि उपयोगकर्ता नाम और पासवर्ड मेल खाते हैं या नहीं।
और अब नियंत्रक से रन विधि का समय आ गया है, जो हमारे नए बने सहायक (सभी नियंत्रकों के लिए मूल आवरण) का उपयोग करता है। हम जाँचते हैं: यदि उपयोगकर्ता अधिकृत है, तो हम उसे नियंत्रण कक्ष दिखाते हैं, अन्यथा हम प्राधिकरण पृष्ठ प्रदर्शित करते हैं:

 run: function(req, res, next) { if(this.authorize(req)) { req.session.fastdelivery = true; req.session.save(function(err) { var v = new View(res, 'admin'); v.render({ title: 'Administration', content: 'Welcome to the control panel' }); }); } else { var v = new View(res, 'admin-login'); v.render({ title: 'Please login' }); } } 

सामग्री प्रबंधन

जैसा कि मैंने इस लेख की शुरुआत में कहा, हमारे पास कई चीजें हैं जो हम प्रशासन करेंगे। प्रक्रिया को सरल बनाने के लिए, चलो सभी डेटा को एक संग्रह में रखते हैं। प्रत्येक प्रविष्टि में निम्नलिखित गुण होंगे: शीर्षक, पाठ, छवि और प्रकार। उत्तरार्द्ध रिकॉर्ड के मालिक का निर्धारण करेगा। उदाहरण के लिए, एक संपर्क पृष्ठ को "संपर्क" प्रकार के साथ केवल एक प्रविष्टि की आवश्यकता होती है, जबकि एक ब्लॉग पेज को अधिक प्रविष्टियों की आवश्यकता होती है। इसलिए, हमें प्रविष्टियों को जोड़ने, हटाने और संपादित करने के लिए तीन नए पृष्ठ जोड़ने होंगे। इससे पहले कि हम नए टेम्प्लेट बनाना, स्टाइल करना और कंट्रोलर में नई चीजें जोड़ना शुरू करें, हमें अपने मॉडल के लिए एक क्लास लिखना होगा, जो MongoDB सर्वर और हमारे एप्लिकेशन के बीच खड़ा होगा, और निश्चित रूप से, हमें एक सुविधाजनक एपीआई प्रदान करेगा।

 // /models/ContentModel.js var Model = require("./Base"), crypto = require("crypto"), model = new Model(); var ContentModel = model.extend({ insert: function(data, callback) { data.ID = crypto.randomBytes(20).toString('hex'); this.collection().insert(data, {}, callback || function(){ }); }, update: function(data, callback) { this.collection().update({ID: data.ID}, data, {}, callback || function(){ }); }, getlist: function(callback, query) { this.collection().find(query || {}).toArray(callback); }, remove: function(ID, callback) { this.collection().findAndModify({ID: ID}, [], {}, {remove: true}, callback); } }); module.exports = ContentModel; 

मॉडल प्रत्येक रिकॉर्ड के लिए एक अद्वितीय आईडी बनाने का ख्याल रखता है। हमें बाद में जानकारी अपडेट करने के लिए इसकी आवश्यकता होगी।
अगर हमें संपर्क पृष्ठ में एक नई प्रविष्टि जोड़ने की आवश्यकता है, तो हम निम्नलिखित लिख सकते हैं:

 var model = new (require("../models/ContentModel")); model.insert({ title: "Contacts", text: "...", type: "contacts" }); 

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

एक पृष्ठ पर सभी नियंत्रणों को प्रदर्शित करने का मतलब है कि हमें उस पृष्ठ पर ध्यान केंद्रित करना चाहिए जो इस पृष्ठ को प्रस्तुत करता है, या, विशेष रूप से, उस डेटा पर जो हम टेम्पलेट को भेजते हैं। इसलिए, मैंने कई एकीकृत सहायक कार्य बनाए, जैसे कि:

 var self = this; ... var v = new View(res, 'admin'); self.del(req, function() { self.form(req, res, function(formMarkup) { self.list(function(listMarkup) { v.render({ title: 'Administration', content: 'Welcome to the control panel', list: listMarkup, form: formMarkup }); }); }); }); 

हां, यह थोड़ा बदसूरत लगता है, लेकिन यह ठीक उसी तरह से काम करता है, जैसा मैं चाहता हूं। पहला सहायक डेल विधि है , जो वर्तमान जीईटी मापदंडों की जांच करता है, और यदि यह संयोजन क्रिया = हटाएं और आईडी = [रिकॉर्ड की आईडी] पाता है, तो यह संग्रह से संबंधित डेटा को हटा देता है। दूसरे फ़ंक्शन को फ़ॉर्म कहा जाता है , यह पृष्ठ के दाईं ओर फ़ॉर्म प्रदर्शित करने के लिए मुख्य रूप से ज़िम्मेदार है। फ़ंक्शन जाँचता है कि क्या फॉर्म सर्वर पर आया है और डेटाबेस में ठीक से अपडेट या रिकॉर्ड बनाता है। अंत में, सूची विधि जानकारी को पुनः प्राप्त करती है और एक HTML तालिका तैयार करती है जिसे बाद में टेम्पलेट पर भेजा जाएगा। इस निर्देश के लिए इन तीन सहायकों का कार्यान्वयन स्रोत कोड में पाया जा सकता है ।
नीचे एक फ़ंक्शन है जो फ़ाइल अपलोड को संभालता है:

 handleFileUpload: function(req) { if(!req.files || !req.files.picture || !req.files.picture.name) { return req.body.currentPicture || ''; } var data = fs.readFileSync(req.files.picture.path); var fileName = req.files.picture.name; var uid = crypto.randomBytes(10).toString('hex'); var dir = __dirname + "/../public/uploads/" + uid; fs.mkdirSync(dir, '0777'); fs.writeFileSync(dir + "/" + fileName, data); return '/uploads/' + uid + "/" + fileName; } 

यदि फ़ाइल सर्वर पर भेजी जाती है, तो अनुरोध ऑब्जेक्ट की .files संपत्ति संबंधित डेटा से भरी जाएगी। हमारे मामले में, हमारे पास निम्न HTML तत्व हैं:

 <input type="file" name="picture" /> 

इसका अर्थ है कि हम भेजे गए डेटा को req.files.picture के माध्यम से एक्सेस कर सकते हैं । जैसा कि ऊपर दिए गए उदाहरण में दिखाया गया है, req.files.picture.path का उपयोग फ़ाइल की कच्ची (कच्ची) सामग्री प्राप्त करने के लिए किया जाता है। इसके अलावा, भेजे गए फ़ाइल को डाउनलोड के लिए बनाई गई निर्देशिका में सहेजा गया है, और बहुत ही अंत में, इस फ़ाइल का संबंधित URL वापस आ गया है। ये सभी ऑपरेशन सिंक्रोनस हैं, लेकिन यह रीडफाइलसंक , mkdirSync और राइटफाइलसंक विधियों के अतुल्यकालिक संस्करण का उपयोग करने के लिए अच्छा अभ्यास है ।

उपयोगकर्ता भाग

सबसे कठिन हिस्सा अब तैयार है। व्यवस्थापक पैनल काम करता है, और हमारे पास ContentModel वर्ग है , जो हमें डेटाबेस में संग्रहीत जानकारी तक पहुंच प्रदान करता है। अब हमें क्या करना चाहिए उपयोगकर्ता भाग के लिए नियंत्रकों को लिखना और उन्हें संग्रहीत सामग्री से बांधना है। यहाँ मुख पृष्ठ के लिए नियंत्रक है - /controllers/Home.js

 module.exports = BaseController.extend({ name: "Home", content: null, run: function(req, res, next) { model.setDB(req.db); var self = this; this.getContent(function() { var v = new View(res, 'home'); v.render(self.content); }) }, getContent: function(callback) { var self = this; this.content = {}; model.getlist(function(err, records) { ... storing data to content object model.getlist(function(err, records) { ... storing data to content object callback(); }, { type: 'blog' }); }, { type: 'home' }); } }); 

होम पेज को "होम" प्रकार के साथ एक प्रविष्टि और "ब्लॉग" प्रकार के साथ चार प्रविष्टियों की आवश्यकता होती है।
एक बार जब नियंत्रक के लिए तैयार है, हम अपने में इसे करने के लिए एक मार्ग जोड़ने की आवश्यकता होगी app.js :

 app.all('/', attachDB, function(req, res, next) { Home.run(req, res, next); }); 

हम पुनः db ऑब्जेक्ट को अनुरोध ऑब्जेक्ट में संलग्न करते हैं । अधिकांश भाग के लिए, वही प्रक्रिया जो हमने व्यवस्थापक पैनल बनाते समय की थी।
उपयोगकर्ता भाग के लिए अन्य पृष्ठ लगभग समान हैं कि उन सभी में एक नियंत्रक है जो मॉडल वर्ग का उपयोग करके डेटा प्राप्त करता है, और निश्चित रूप से, एक मार्ग है। दो दिलचस्प पहलू हैं जिन्हें मैं अधिक विस्तार से कवर करना चाहूंगा। पहला एक ब्लॉग पेज से जुड़ा हुआ है। पेज को सभी लेखों के साथ-साथ एकल भी दिखाना चाहिए। मार्गों की एक जोड़ी को परिभाषित करें:

 app.all('/blog/:id', attachDB, function(req, res, next) { Blog.runArticle(req, res, next); }); app.all('/blog', attachDB, function(req, res, next) { Blog.run(req, res, next); }); 

वे दोनों एक ही नियंत्रक का उपयोग करते हैं: ब्लॉग , लेकिन वे दो अलग-अलग रन विधियों को कहते हैं । लाइन / ब्लॉग /: आईडी पर ध्यान दें । यह मार्ग URL जैसे: / ब्लॉग / 4e3455635b4a6f6dccfaa1e50ee71f1cde75222b से मेल खाएगा , जहां यह लंबी हैश req.params.id संपत्ति के माध्यम से सुलभ होगी । दूसरे शब्दों में, हम गतिशील मापदंडों को परिभाषित कर सकते हैं। हमारे मामले में, यह प्रविष्टि (लेख) की आईडी होगी। अब जब हमने इस बारे में जान लिया है, तो हम प्रत्येक लेख के लिए एक अनोखा पेज तैयार कर सकते हैं।
दूसरा दिलचस्प पहलू यह है कि मैं सेवाओं, करियर और संपर्कों के पेज कैसे बनाऊंगा। यह स्पष्ट है कि वे सभी डेटाबेस से केवल एक रिकॉर्ड का उपयोग करेंगे। यदि हमें प्रत्येक पृष्ठ के लिए एक नियंत्रक बनाने की आवश्यकता है, तो हम बस उसी कोड को कॉपी और पेस्ट करेंगे और उसमें टाइप फ़ील्ड को बदलेंगे । ऐसा करने का एक बेहतर तरीका है, एक एकल नियंत्रक के माध्यम से जो अपनी रन विधि में एक रिकॉर्ड प्रकार को स्वीकार करेगा । ये मार्ग हैं:

 app.all('/services', attachDB, function(req, res, next) { Page.run('services', req, res, next); }); app.all('/careers', attachDB, function(req, res, next) { Page.run('careers', req, res, next); }); app.all('/contacts', attachDB, function(req, res, next) { Page.run('contacts', req, res, next); }); 

और यहां कंट्रोलर कैसा दिखेगा:

 module.exports = BaseController.extend({ name: "Page", content: null, run: function(type, req, res, next) { model.setDB(req.db); var self = this; this.getContent(type, function() { var v = new View(res, 'inner'); v.render(self.content); }); }, getContent: function(type, callback) { var self = this; this.content = {} model.getlist(function(err, records) { if(records.length > 0) { self.content = records[0]; } callback(); }, { type: type }); } }); 

परिनियोजित

एक्सप्रेस वेबसाइट की तैनाती अनिवार्य रूप से Node.js पर किसी अन्य एप्लिकेशन को तैनात करने से अलग नहीं है:

• फाइलें सर्वर पर अपलोड की जाती हैं
• नोड प्रक्रिया को रोका जाना चाहिए (यदि यह चल रहा है)
• सभी आवश्यक निर्भरताएं स्थापित करने के लिए, npm इंस्टॉल कमांड चलाया जाता है
• मुख्य नोड स्क्रिप्ट फिर से चलता है

ध्यान रखें कि नोड एक बहुत ही युवा उत्पाद है, और सब कुछ आपकी अपेक्षा के अनुसार काम नहीं कर सकता है, लेकिन हर समय सुधार किए जाते हैं। उदाहरण के लिए, हमेशा के लिए मॉड्यूल आपको Node.js. के निरंतर संचालन की गारंटी देता है। आप इसे निम्न कमांड चलाकर चला सकते हैं:

 forever start yourapp.js 

यह वही है जो मैं अपने सर्वर पर उपयोग करता हूं। यह छोटा उपकरण एक बड़ी समस्या को हल करता है। यदि आप नोड yourapp.js कमांड के साथ अपना एप्लिकेशन लॉन्च करते हैं , तो जैसे ही स्क्रिप्ट विफल होती है, सर्वर क्रैश हो जाएगा, जबकि हमेशा के लिए बस एप्लिकेशन को पुनरारंभ करता है।
मैं एक सिस्टम प्रशासक नहीं हूं, लेकिन मैं अपाचे और नग्नेक्स में नोड अनुप्रयोगों को एकीकृत करने में अपने अनुभव को साझा करना चाहता हूं , क्योंकि मेरा मानना ​​है कि एकीकरण विकास प्रक्रिया का हिस्सा है। जैसा कि आप जानते हैं, अपाचे आमतौर पर पोर्ट 80 के तहत चलता है, जिसका अर्थ है कि यदि आप लोकलहोस्ट या लोकलहोस्ट पर ब्राउज़र में जाते हैं: 80, आपको अपाचे सर्वर द्वारा दिया गया एक पेज दिखाई देगा, और सबसे अधिक संभावना है कि आपकी नोड स्क्रिप्ट एक अलग पोर्ट पर सुन रही है। इसलिए, आपको एक वर्चुअल होस्ट जोड़ना होगा जो अनुरोध प्राप्त करेगा और उन्हें वांछित पोर्ट पर भेज देगा। उदाहरण के लिए, मैं उस साइट को होस्ट करना चाहता हूं जिसे मैंने अपने स्थानीय अपाचे सर्वर पर, पता एक्सप्रेसकॉमप्लेव्यूसाइट / .dev के तहत बनाया था । पहली चीज जो मुझे करने की ज़रूरत है वह है मेरा डोमेन होस्ट्स फ़ाइल में जोड़ना।

 127.0.0.1 expresscompletewebsite.dev 

उसके बाद, मुझे Apache सर्वर कॉन्फ़िगरेशन निर्देशिका में स्थित httpd-vhosts.conf फ़ाइल को बदलना होगा:

 # expresscompletewebsite.dev <VirtualHost *:80> ServerName expresscompletewebsite.dev ServerAlias www.expresscompletewebsite.dev ProxyRequests off <Proxy *> Order deny,allow Allow from all </Proxy> <Location /> ProxyPass http://localhost:3000/ ProxyPassReverse http://localhost:3000/ </Location> </VirtualHost> 

सर्वर अभी भी पोर्ट 80 से अनुरोधों को स्वीकार करता है, लेकिन उन्हें 3000 पोर्ट करने के लिए अग्रेषित करता है, जो सिर्फ नोड स्क्रिप्ट के लिए सुनता है।
Nginx को कॉन्फ़िगर करना बहुत सरल है, और स्पष्ट रूप से, यह Node.js- आधारित अनुप्रयोगों की मेजबानी के लिए सबसे अच्छा विकल्प है। बस Apache कॉन्फ़िगरेशन में, आपको डोमेन को होस्ट फ़ाइल में जोड़ना होगा । उसके बाद, / साइट्स-सक्षम निर्देशिका में एक नई फ़ाइल बनाएं , जो कि Nginx स्थापित है जहां स्थित है। फ़ाइल की सामग्री कुछ इस तरह दिखनी चाहिए:

 server { listen 80; server_name expresscompletewebsite.dev location / { proxy_pass http://127.0.0.1:3000; proxy_set_header Host $http_host; } } 

याद रखें कि आप एक ही होस्ट कॉन्फ़िगरेशन के साथ एक ही समय में Apache और Nginx शुरू नहीं कर सकते हैं। ऐसा इसलिए है क्योंकि वे दोनों पोर्ट 80 पर सुनते हैं। इसके अलावा, यदि आप किसी कॉम्बैट सर्वर पर उपरोक्त कोड स्निपेट्स का उपयोग करने की योजना बनाते हैं, तो आप स्वयं अधिक विस्तृत सर्वर कॉन्फ़िगरेशन जानकारी के लिए इंटरनेट पर खोज कर सकते हैं। जैसा कि मैंने कहा, मैं इस क्षेत्र का विशेषज्ञ नहीं हूं।

निष्कर्ष

एक्सप्रेस एक महान ढांचा है जो आपको वेब अनुप्रयोगों के निर्माण के लिए एक अच्छी नींव देता है। जैसा कि आप स्वयं देख सकते हैं, यह केवल पसंद की बात है, आप इसका विस्तार कैसे करेंगे और आप इसके साथ क्या उपयोग करेंगे। यह कई अद्भुत बिचौलियों का उपयोग करके नियमित कार्यों को सरल बनाता है और डेवलपर्स के लिए सबसे स्वादिष्ट लागू करने की प्रक्रिया को छोड़ देता है।

स्रोत कोड

GitHub पर हमने इस लेख में जो वेबसाइट बनाई है, उसका स्रोत कोड https://github.com/tutsplus/build-complete-website-expressjs है । कांटा और उन्नयन के लिए स्वतंत्र महसूस करें। यहाँ एक वेबसाइट शुरू करने के लिए एक कदम दर कदम गाइड है:

• स्रोत कोड डाउनलोड करें
• डाउनलोड किए गए एप्लिकेशन की निर्देशिका पर जाएं
• चल रहा है npm स्थापित
• मोंगोडब डेमॉन चलाएं
• नोड app.js चलाएँ