MongoDB
 sql >> डेटाबेस >  >> NoSQL >> MongoDB

NodeJS ऐप संरचना के बारे में स्पष्ट होना चाहते हैं (पूर्ण जावास्क्रिप्ट स्टैक)

ठीक है, यह एक बहुत व्यापक प्रश्न है और मैं निश्चित रूप से कोई विशेषज्ञ नहीं हूँ, लेकिन मैं यहाँ अपनी पूरी कोशिश करूँगा।

TL;DR

  • routes नियंत्रक हैं जो बताते हैं कि जब कोई उपयोगकर्ता अपने ब्राउज़र को आपके ऐप के भीतर एक निश्चित पथ पर नेविगेट करता है तो कौन सा तर्क निष्पादित करना है, जिसमें कौन से दृश्य प्रस्तुत करना है और कौन सा डेटा उन दृश्यों को भेजना है
  • models बस यही हैं - आपके आवेदन के भीतर डेटा मॉडल
  • module.exports = एक फ़ाइल को बताता है कि यह वास्तव में "निर्यात" क्या है, यही वह कोड है जिसे निष्पादित करने या आपकी मुख्य ऐप फ़ाइल से एक्सेस करने की आवश्यकता है।
  • require(..) एक मॉड्यूल शामिल है। आप इसे एक चर पर सेट कर सकते हैं ताकि आप बाद में मॉड्यूल फ़ंक्शन को कॉल कर सकें, या बस एक फ़ंक्शन निष्पादित कर सकते हैं यदि यह सब module.exports है रिटर्न।

इन तकनीकों के संयोजन से आपको अपने किसी भी एप्लिकेशन के लिए एक ठोस ढांचा तैयार करने में मदद मिल सकती है।

लंबा उत्तर

Express आपके Node.js एप्लिकेशन को संरचित करने के लिए एक ठोस ढांचा प्रदान करता है। नोड एक्सप्रेस से पूरी तरह से स्वतंत्र है, लेकिन एक्सप्रेस कितना लोकप्रिय है, इसके कारण वे व्यावहारिक रूप से हाथ से चलते हैं। एक बार स्थापित हो जाने पर, एक्सप्रेस का उपयोग आपके लिए एक मचान वेब प्रोजेक्ट (विकल्पों के साथ) उत्पन्न करने के लिए किया जा सकता है, यदि आप चाहें तो इसके शीर्ष पर निर्माण कर सकते हैं।

नियंत्रक

एक जेनरेट किया गया प्रोजेक्ट /routes/index.js . बनाएगा , जो (यदि आप MVC को समझते हैं) अनिवार्य रूप से आपका मुख्य नियंत्रक . है . एक्सप्रेस में एक मार्ग इस प्रकार लिखा जाता है:

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

आइए इसे तोड़ दें:हमारे एप्लिकेशन वेरिएबल (ऐप) को बताया जा रहा है कि एक GET अनुरोध पर '/path' req, res, next . के साथ एक अनाम कॉलबैक फ़ंक्शन निष्पादित करने के लिए चर (क्रमशः अनुरोध, प्रतिक्रिया, कॉलबैक)। मुझे इसे एक कस्टम ईवेंट हैंडलर की तरह सोचना मददगार लगता है।

इस बिंदु पर यह ध्यान रखना महत्वपूर्ण है कि हम app.post . को भी कॉल कर सकते हैं URL पर पोस्ट के लिए समान सिंटैक्स के साथ प्राप्त करने के विपरीत।

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

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

    //some business logic

    res.render('views/home');
});

जब उपयोगकर्ता हमारे एप्लिकेशन का इंडेक्स पथ प्राप्त करने का प्रयास करता है (/ ), हम बस अपना home . प्रस्तुत करते हैं देखें कि, हमारे प्रोजेक्ट की जड़ से, एक views . में संग्रहीत है फ़ोल्डर।

लेकिन क्या होगा अगर हम इसे मॉड्यूलर करना चाहते हैं ताकि हम अपने सभी मार्गों को अपने मुख्य app.js में घोषित नहीं कर रहे हैं या server.js ?

हम module.exports = .. . का उपयोग करते हैं हमारे मॉड्यूल में हमारे सर्वर को यह बताने के लिए कि वास्तव में क्या शामिल करना है। मेरे नियंत्रक में, मैं एक एकल फ़ंक्शन निर्यात करता हूं जो एप्लिकेशन को एक तर्क के रूप में लेता है और इसका उपयोग हमारे मार्गों को परिभाषित करने के लिए करता है:

नियंत्रक/उपयोगकर्ता.जेएस

 module.exports = function(app){

    app.get('/users', function(req, res){
        var users = req.db.collection('users').find();
        if (!users) {
            console.log("no users found");
            res.redirect('/');
        } else {
            res.render('users/index', {users : users});
        }
    });

};

req.db के बारे में चिंता न करें कोड, मैं अपने आवेदन में अनुरोध के लिए डेटाबेस संलग्न करता हूं लेकिन यह डिफ़ॉल्ट रूप से नहीं किया जाता है। सीधे शब्दों में समझें कि मुझे यहां 'उपयोगकर्ताओं' की एक सूची मिल रही है, और यदि कोई नहीं है तो उपयोगकर्ता को मेरे ऐप की अनुक्रमणिका पर रीडायरेक्ट कर रहा है।

मॉडल

Mongoose हमें मॉडल लिखने के लिए एक बेहतरीन इंटरफ़ेस प्रदान करता है। नेवले के साथ, मॉडल लिखना तीन चरणों वाली प्रक्रिया है:

  • स्कीमा परिभाषित करें
  • मॉडल तर्क को परिभाषित करें
  • मॉडल बनाएं और निर्यात करें

यहां एक User का उदाहरण दिया गया है मॉडल:

मॉडल/User.js

var mongoose = require('mongoose'),
    userSchema = new mongoose.Schema({

        name: { type: String, required: true },
        joinDate: {type: Date, default: date.now }

    }),
    User = mongoose.model('user', userSchema);

module.exports = user;

सर्वर ऐप

module.exports हमारे कोडबेस में कुछ प्रतिरूपकता को परिभाषित करने में हमारी मदद करने के लिए उपयोग किया जाता है। जब हम एक नोड अनुप्रयोग चलाते हैं, तो हम अंततः एक एकल JavaScript फ़ाइल चला रहे होते हैं (आप पहले ही उस फ़ाइल को server.js के साथ देख चुके होते हैं। या app.js )

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

| Controllers
    - User.js
| Models
    - User.js
| Views
app.js

app.js . से अपने उपयोगकर्ता नियंत्रक को शामिल करने के लिए , आप लिखेंगे:require('./Controllers/User') . चूंकि हमारे नियंत्रक मॉड्यूल केवल कार्यों को निर्यात करते हैं, इसलिए हम अंत में केवल कोष्ठक जोड़कर (जो भी पैरामीटर आवश्यक हैं) हमारे आवश्यकता कथन के तुरंत बाद उस फ़ंक्शन को कॉल कर सकते हैं। मेरे नियंत्रकों सहित ऐसा दिखता है:

require('./Controllers/User')(app)

मैं वास्तविक ऐप में जा रहा हूं, क्योंकि मेरा मॉड्यूल (नीचे) बस एक फ़ंक्शन निर्यात करता है जो मेरे ऐप के मार्गों में व्यावसायिक तर्क जोड़ता है। इसे केवल कॉल करने की आवश्यकता है और कभी भी उपयोग नहीं किया जाना चाहिए, इसलिए मैं अपने नियंत्रक को बाद में कॉल विधियों के लिए एक चर के रूप में कैप्चर नहीं करता।

मॉडल शामिल करना थोड़ा अलग है, क्योंकि हम कुछ ऑपरेशन करना चाहते हैं जो हमारा मॉडल परिभाषित करता है। हम अपने आवश्यकता कोड को थोड़ा सा बदलकर ऐसा कर सकते हैं:

var User = require('./Models/User');

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

User.find({}, function(err, users){ .. });

उपरोक्त फ़ंक्शन हमारे सभी उपयोगकर्ताओं को ढूंढेगा, और फिर एक संभावित err के साथ एक अनाम फ़ंक्शन निष्पादित करेगा। (यदि कोई समस्या नहीं है तो शून्य है) और फिर JSON प्रारूप में हमारे उपयोगकर्ताओं की एक सूची। बहुत अच्छा।

इन सभी अवधारणाओं को मिलाकर आप एक्सप्रेस और Node.js का उपयोग करके एक बुनियादी वेब एप्लिकेशन कैसे बनाते हैं। कृपया मुझे टिप्पणियों में बताएं कि क्या कुछ है जो मैं स्पष्ट कर सकता हूं कि मैं एक्सप्रेस का उपयोग कैसे करता हूं। यह बहुत सतही स्तर का ज्ञान है, और मैं आपके ऐप्स की क्षमताओं को बढ़ाने के लिए दस्तावेज़ीकरण में खुदाई करने और प्लगइन्स को देखने का सुझाव देता हूं। शुभकामनाएँ!




  1. Redis
  2.   
  3. MongoDB
  4.   
  5. Memcached
  6.   
  7. HBase
  8.   
  9. CouchDB
  1. पाइमोंगो के साथ मैप कम करने का निष्पादन विफल रहा लेकिन मोंगो शेल में सफलता

  2. सरणी में तत्व अपडेट करें यदि मौजूद है तो MongoDb में उस सरणी में नया तत्व डालें

  3. Mongo . में बिनिंग और सारणीबद्ध (अद्वितीय/गिनती)

  4. एक POCO में एक BsonArray को एक सूची <> में मैप करना

  5. $arrayElemAt का उपयोग कैसे करें और MongoDB $ प्रोजेक्शन में उस तत्व से फ़ील्ड निकालें?