दिलचस्प पोस्ट
आज एनएसडीट प्राप्त करें, कल, इस सप्ताह, पिछले सप्ताह, इस महीने, पिछले महीने … चर किसी निर्भरता के बिना चलाने के लिए पायथन स्क्रिप्ट स्टैंडअलोन कैसे निष्पादित किया जा सकता है? Matplotlib टिकटिक लेबल फ़ॉन्ट आकार छोटे बनाते हैं क्या मैं अपना स्पष्ट प्रकार तुलनित्र इनलाइन निर्दिष्ट कर सकता हूं? कैनवास तत्व में मैं एक सरल onClick ईवेंट हैंडलर कैसे जोड़ूं? शेल लिपि में वाई वाई वाईवाय-एमएम-डीडी प्रारूप की तारीख किसी वेबसाइट पर Google डिस्क में संग्रहीत फ़ाइलों को प्रदर्शित करना (उदा JasperReports में स्थिति के आधार पर टेक्स्ट फ़ील्ड डेटा रंग (अग्रभूमि रंग) बदलें ट्रम्पोलिन फ़ंक्शन क्या है? रीसाइक्लेअरव्यू + ऐपबेरलायूट के साथ झांकना जावा से एक नया प्रॉम्प्ट / टर्मिनल विंडो खोलें UIWebView: एप पृष्ठभूमि में प्रवेश करती है जब आईओएस 6 में HTML5 ऑडियो रोकता है एंड्रॉइड स्टूडियो – एंड्रॉइड एसडीके पथ को कैसे बदलें मोबाइल डिवाइस पर बूटस्ट्रैप 3 – डेस्कटॉप दृश्य एक अनुप्रयोग सर्वर और एक सर्वलेट कंटेनर के बीच का अंतर?

मॉड्यूल। एक्सपोर्ट एक्सपोर्ट बनाम नोड। जेएस में

मुझे एक नोड। जेएस मॉड्यूल में निम्नलिखित अनुबंध मिला है:

module.exports = exports = nano = function database_module(cfg) {...} 

मुझे आश्चर्य है कि module.exports एंड exports बीच अलग-अलग और किस प्रकार दोनों का उपयोग यहां किया गया है।

वेब के समाधान से एकत्रित समाधान "मॉड्यूल। एक्सपोर्ट एक्सपोर्ट बनाम नोड। जेएस में"

सेटिंग module.exports फ़ंक्शन को फ़ंक्शन की तरह module.exports अनुमति देता है जब required । बस exports स्थापित करने से फ़ंक्शन को निर्यात करने की अनुमति नहीं होगी क्योंकि नोड वस्तु module.exports निर्यात करता है। निर्यात संदर्भ। निम्नलिखित कोड उपयोगकर्ता को समारोह कॉल करने की अनुमति नहीं देगा।

module.js

निम्नलिखित काम नहीं करेगा

 exports = nano = function database_module(cfg) {return;} 

module.exports सेट होने पर निम्नलिखित कार्य करेगा।

 module.exports = exports = nano = function database_module(cfg) {return;} 

कंसोल

 var func = require('./module.js'); // the following line will **work** with module.exports func(); 

मूलतः नोड.जेएस ऑब्जेक्ट को exports नहीं करता है जो वर्तमान संदर्भों को निर्यात करता है, लेकिन निर्यात के मूल संदर्भों के गुणों को exports । हालांकि Node.js ऑब्जेक्ट module.exports निर्यात करता है। एक्सपोर्ट्स संदर्भ, आप इसे फ़ंक्शन की तरह कॉल करने की इजाजत देते हैं।


दूसरे कम से कम महत्वपूर्ण कारण

वे module.exports दोनों को निर्धारित करते हैं। module.exports और exports सुनिश्चित करने के लिए exports किए गए ऑब्जेक्ट को संदर्भित नहीं कर रहे हैं। दोनों को सेट करके आप शॉर्टहाउंड के रूप में exports उपयोग करते हैं और बाद में सड़क के नीचे संभावित बग से बचें।

module.exports.prop = true exports.prop = true बजाय module.exports.prop = true का उपयोग करते हुए अक्षर बचाता है और भ्रम से बचा जाता है।

हालांकि सवाल का जवाब और बहुत पहले स्वीकार किया गया है, बस मेरे 2 सेंट साझा करना चाहते हैं:

आप कल्पना कर सकते हैं कि आपकी फ़ाइल की शुरुआत में कुछ ऐसी चीज है (बस स्पष्टीकरण के लिए):

 var module = new Module(...); var exports = module.exports; 

यहां छवि विवरण दर्ज करें

तो जो कुछ भी आप करते हैं, module.exports ध्यान रखें कि मॉड्यूल। exports और नहीं exports आपके मॉड्यूल से लौटा दिए जाएंगे, जब आपको उस मॉड्यूल की कहीं और आवश्यकता होगी।

तो जब आप ऐसा कुछ करते हैं:

 exports.a = function() { console.log("a"); } exports.b = function() { console.log("b"); } 

आप उस वस्तु को 2 फ़ंक्शन 'ए' और 'बी' जोड़ रहे हैं, जिस पर मॉड्यूल। एक्सपोर्ट्स भी बताते हैं, इसलिए लौटने वाले प्रकार का एक object : { a: [Function], b: [Function] }

बेशक यह एक ही परिणाम है जो आप मिलेगा यदि आप module.exports बजाय exports बजाय इस उदाहरण में उपयोग कर रहे हैं।

यह वह मामला है, जहां आप अपने मॉड्यूल चाहते हैं। एक्सपोर्ट किए गए मानों के कंटेनर की तरह व्यवहार करना ऐसे मामले में जहां आप केवल कन्स्ट्रक्टर फ़ंक्शन का निर्यात करना चाहते हैं, आप क्या करेंगे? (फिर से याद रखें कि मॉड्यूल। एक्सपोर्ट्स आपको कुछ आवश्यक होने पर वापस नहीं लौटाएंगे, निर्यात नहीं)।

 module.exports = function Something() { console.log('bla bla'); } 

अब परिणाम लौटने के प्रकार 'function' और आप इसे आवश्यक कर सकते हैं और तत्काल इनका उपयोग कर सकते हैं:
var x = require('./file1.js')(); क्योंकि आप लौटने के परिणाम को एक फ़ंक्शन बनने के लिए अधिलेखित करते हैं।

इस मामले में आप ऐसा क्यों नहीं इस्तेमाल कर सकते हैं:

 exports = function Something() { console.log('bla bla'); } 

क्योंकि इस exports संदर्भ में 'ऑब्जेक्ट' को अब 'पॉइंट' नहीं होता है, जहां module.exports इंगित करते हैं, इसलिए exports और module.exports बीच रिश्ते नहीं हैं। exports अब और नहीं इस मामले में मॉड्यूल। एक्सपोर्ट्स अभी भी रिक्त ऑब्जेक्ट {} को इंगित करती हैं जो लौटा दिए जाएंगे

किसी अन्य विषय से जवाब स्वीकार किया जाना चाहिए: क्या जावास्क्रिप्ट संदर्भ से पास है?

मूलतः इसका जवाब है कि वास्तव में क्या होता है जब एक मॉड्यूल आवश्यक बयान के माध्यम से आवश्यक होता है। यह मानते हुए पहली बार मॉड्यूल की आवश्यकता होती है।

उदाहरण के लिए:

 var x = require('file1.js'); 

file1.js की सामग्री:

 module.exports = '123'; 

जब उपरोक्त कथन निष्पादित किया जाता है, तो एक Module वस्तु बनाई जाती है। इसका कन्स्ट्रक्टर फ़ंक्शन है:

 function Module(id, parent) { this.id = id; this.exports = {}; this.parent = parent; if (parent && parent.children) { parent.children.push(this); } this.filename = null; this.loaded = false; this.children = []; } 

जैसा कि आप देखते हैं कि प्रत्येक मॉड्यूल ऑब्जेक्ट नाम exports साथ एक संपत्ति है यह अंततः require भाग के रूप में वापस आ गया require

आवश्यकता के अगले चरण में file1.js की सामग्री को नीचे की तरह एक गुमनाम समारोह में लपेट करना है:

 (function (exports, require, module, __filename, __dirname) { //contents from file1.js module.exports = '123; }); 

और इस गुमनाम क्रिया को निम्नलिखित तरीके से लागू किया जाता है, यहां पर module यहां पहले निर्मित Module ऑब्जेक्ट को संदर्भित करता है।

 (function (exports, require, module, __filename, __dirname) { //contents from file1.js module.exports = '123; }) (module.exports,require, module, "path_to_file1.js","directory of the file1.js"); 

जैसा कि हम फ़ंक्शन के अंदर देख सकते हैं, औपचारिक तर्क का exports module.exports को संदर्भित करता है। exports संक्षेप में यह मॉड्यूल प्रोग्रामर को प्रदान की जाने वाली सुविधा है।

हालांकि देखभाल के साथ इस सुविधा का उपयोग करने की आवश्यकता है किसी भी मामले में यदि निर्यात करने के लिए एक नया ऑब्जेक्ट प्रदान करने की कोशिश कर रहे हैं तो हम इसे इस तरह से करते हैं।

 exports = module.exports = {}; 

यदि हम इसे गलत तरीके से module.exports करते हैं, तो मॉड्यूल। module.exports अभी भी मॉड्यूल उदाहरण के हिस्से के रूप में बनाए गए ऑब्जेक्ट की ओर इशारा कर रहे होंगे।

 exports = {}; 

चूंकि उपरोक्त निर्यात ऑब्जेक्ट में कुछ भी जोड़ने के परिणामस्वरूप मॉड्यूल पर कोई असर नहीं होगा। एक्सपोर्ट ऑब्जेक्ट और आवश्यकता के भाग के रूप में कुछ भी निर्यात या लौटा नहीं दिया जाएगा।

प्रारंभ में, module.exports=exports , और require फ़ंक्शन ऑब्जेक्ट module.exports देता है। module.exports संदर्भित करता है।

यदि हम ऑब्जेक्ट में संपत्ति जोड़ते हैं , तो exports.a=1 कहते हैं। ए exports.a=1 , फिर मॉड्यूल। एक्सपोर्ट्स और निर्यात अभी भी उसी ऑब्जेक्ट का संदर्भ देते हैं। इसलिए यदि हम कॉल की आवश्यकता होती है और मॉड्यूल को एक चर में निर्दिष्ट करते हैं, तो चर में एक संपत्ति होती है और इसका मान 1 है;

लेकिन अगर हम उनमें से एक को ओवरराइड करते हैं, उदाहरण के लिए, export exports=function(){} , तो वे अलगअलग हैं: निर्यात एक नया ऑब्जेक्ट और मॉड्यूल। एक्सपोर्ट्स को मूल ऑब्जेक्ट को संदर्भित करता है। और अगर हमें फाइल की आवश्यकता होती है, तो यह नया ऑब्जेक्ट वापस नहीं लौटाएगा, क्योंकि मॉड्यूल। एक्सपोर्ट्स नए ऑब्जेक्ट का उल्लेख नहीं करती हैं।

मेरे लिए, मैं नई संपत्ति जोड़ना जारी रखूंगा, या दोनों को एक नए ऑब्जेक्ट पर ओवरराइड कर दूंगा। बस एक ओवरराइड सही नहीं है और ध्यान रखें कि module.exports असली बॉस है।

exports और मॉड्यूल। exports समान हैं जब तक कि आप अपने मॉड्यूल के भीतर exports पुन: निर्दिष्ट नहीं करते हैं।

इसके बारे में सोचने का सबसे आसान तरीका है, यह सोचना है कि यह रेखा प्रत्येक मॉड्यूल के शीर्ष पर निहित है

 var exports = module.exports = {}; 

यदि आपके मॉड्यूल के भीतर, आप exports को फिर से असाइन करते हैं, तो आप इसे अपने मॉड्यूल में पुन: असाइन करते हैं और यह अब मॉड्यूल के बराबर नहीं है। module.exports यही कारण है कि यदि आप कोई फ़ंक्शन निर्यात करना चाहते हैं, तो आपको यह करना होगा:

 module.exports = function() { ... } 

अगर आप बस अपना function() { ... } को exports लिए सौंपा है, तो आप module.exports लिए अब बिन्दु के लिए exports पुन: असाइन करेंगे।

यदि आप अपने फ़ंक्शन को हर बार module.exports द्वारा module.exports नहीं करना चाहते हैं, तो आप ऐसा कर सकते हैं:

 module.exports = exports = function() { ... } 

ध्यान दें कि module.exports बाएं सबसे तर्क है।

exports लिए गुणों को सम्मिलित करना समान नहीं है क्योंकि आप इसे पुन: असाइन नहीं कर रहे हैं। यही कारण है कि यह काम करता है

 exports.foo = function() { ... } 

जावास्क्रिप्ट संदर्भ से गुजरता है

जावास्क्रिप्ट के संदर्भ में ऑब्जेक्ट पास किए जाने के तरीके के साथ ऐसा करना एक सूक्ष्म अंतर है।

exports और module.exports एक ही वस्तु के लिए दोनों बिंदुओं को exportsexports एक चर और मॉड्यूल है। exports मॉड्यूल ऑब्जेक्ट का एक विशेषता है।

कहो मैं इस तरह कुछ लिख रहा हूं:

 exports = {a:1}; module.exports = {b:12}; 

exports और module.exports exports अब विभिन्न ऑब्जेक्ट्स को इंगित करते हैं। संशोधित परिवर्तन अब मॉड्यूल को संशोधित नहीं करता। निर्यात

जब आयात समारोह module.exports निरीक्षण करता है। module.exports यह हो जाता है {b:12}

मैं सिर्फ कुछ परीक्षण करता हूं, यह पता चला है कि, नोडजे के मॉड्यूल कोड के अंदर, यह कुछ ऐसा होना चाहिए:

 var module.exports = {}; var exports = module.exports; 

इसलिए:

1:

 exports = function(){}; // this will not work! as it make the exports to some other pointer module.exports = function(){}; // it works! cause finally nodejs make the module.exports to export. 

2:

 exports.abc = function(){}; // works! exports.efg = function(){}; // works! 

3: लेकिन, इस मामले में, जबकि

 module.exports = function(){}; // from now on we have to using module.exports to attach more stuff to exports. module.exports.a = 'value a'; // works exports.b = 'value b'; // the b will nerver be seen cause of the first line of code we have do it before (or later) 

मैनुअल प्रकाशन से एक्शन बुक में नोड मॉड्यूल के बारे में लिखा गया एक अच्छा वर्णन है।
आखिरकार आपके आवेदन में निर्यात किया जाता है, मॉड्यूल। एक्सपोर्ट्स
निर्यात को बस मॉड्यूल के लिए एक वैश्विक संदर्भ के रूप में सेट किया जाता है। एक्सपोर्ट्स , जिसे शुरू में एक रिक्त ऑब्जेक्ट के रूप में परिभाषित किया गया है जिसे आप संपत्तियों में जोड़ सकते हैं तो exports.myFunc मॉड्यूल के लिए सिर्फ लघुकोड है। एक्सपोर्ट्स.मैंफंक

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

 module.exports = exports = db; 

मैं कुछ परीक्षणों के माध्यम से गया और मुझे लगता है कि इस विषय पर कुछ प्रकाश डाला जा सकता है …

app.js :

 var ... , routes = require('./routes') ...; ... console.log('@routes', routes); ... 

/routes/index.js संस्करण:

 exports = function fn(){}; // outputs "@routes {}" exports.fn = function fn(){}; // outputs "@routes { fn: [Function: fn] }" module.exports = function fn(){}; // outputs "@routes function fn(){}" module.exports.fn = function fn(){}; // outputs "@routes { fn: [Function: fn] }" 

मैंने नई फाइलें भी जोड़े हैं:

./routes/index.js :

 module.exports = require('./not-index.js'); module.exports = require('./user.js'); 

./routes/not-index.js :

 exports = function fn(){}; 

./routes/user.js :

 exports = function user(){}; 

हम आउटपुट "@ रुटिंग {}" प्राप्त करते हैं


./routes/index.js :

 module.exports.fn = require('./not-index.js'); module.exports.user = require('./user.js'); 

./routes/not-index.js :

 exports = function fn(){}; 

./routes/user.js :

 exports = function user(){}; 

हम आउटपुट "@ रुटिंग्स {fn: {}, उपयोगकर्ता: {}}" प्राप्त करते हैं


./routes/index.js :

 module.exports.fn = require('./not-index.js'); module.exports.user = require('./user.js'); 

./routes/not-index.js :

 exports.fn = function fn(){}; 

./routes/user.js :

 exports.user = function user(){}; 

हम आउटपुट "@ रुटिंग्स {उपयोगकर्ता: [फ़ंक्शन: उपयोगकर्ता]}" प्राप्त करते हैं, यदि हम user.js को { ThisLoadedLast: [Function: ThisLoadedLast] } , तो हम आउटपुट "@ रुटिंग्स {इसलोडेडलेस्ट: [फंक्शन: यह लोडेडलेस्ट]} प्राप्त करते हैं। "।


लेकिन अगर हम संशोधित करते हैं ./routes/index.js

./routes/index.js :

 module.exports.fn = require('./not-index.js'); module.exports.ThisLoadedLast = require('./user.js'); 

./routes/not-index.js :

 exports.fn = function fn(){}; 

./routes/user.js :

 exports.ThisLoadedLast = function ThisLoadedLast(){}; 

… हमें "@ रुटिंग्स {एफ एन: {एफ एन: [फ़ंक्शन: एफ एन]} मिलती है, यह लोडेडः पिछले: {यह लोडेड पिछला: [फ़ंक्शन: यह लोडेडलेस्ट]}}"

इसलिए मैं हमेशा अपने मॉड्यूल परिभाषाओं में मॉड्यूल का उपयोग करने का सुझाव देता हूं।

मैं पूरी तरह से समझ नहीं पा रहा हूं कि आंतरिक रूप से नोड के साथ क्या हो रहा है, लेकिन कृपया टिप्पणी करें यदि आप इसे अधिक समझ सकते हैं क्योंकि मुझे यकीन है कि यह मदद करता है।

– हैप्पी कोडिंग

यह दिखाता है कि किस प्रकार require() अपने सरलतम रूप में काम करता है, सुवक्ता जावास्क्रिप्ट से उत्तपन किया गया

समस्या यह संभव नहीं है कि किसी मॉड्यूल को निर्यात ऑब्जेक्ट के अलावा किसी अन्य मूल्य को निर्यात करना संभव न हो, जैसे फ़ंक्शन। उदाहरण के लिए, एक मॉड्यूल उस ऑब्जेक्ट प्रकार के केवल कन्स्ट्रक्टर को निर्यात करना चाह सकता है जिसे वह परिभाषित करता है। अभी, यह ऐसा नहीं कर सकता क्योंकि यह हमेशा exports ऑब्जेक्ट का उपयोग करता है जो इसे निर्यात मूल्य के रूप में बनाता है।

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

 function require(name) { if (name in require.cache) return require.cache[name]; var code = new Function("exports, module", readFile(name)); var exports = {}, module = {exports: exports}; code(exports, module); require.cache[name] = module.exports; return module.exports; } require.cache = Object.create(null); 

यहां का परिणाम है

 console.log("module:"); console.log(module); console.log("exports:"); console.log(exports); console.log("module.exports:"); console.log(module.exports); 

यहां छवि विवरण दर्ज करें

इसके अलावा:

 if(module.exports === exports){ console.log("YES"); }else{ console.log("NO"); } //YES 

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

 var a = {},md={}; 

// सबसे पहले, निर्यात और मॉड्यूल। निर्यात एक ही खाली वस्तु को इंगित करते हैं

 exp = a;//exports =a; md.exp = a;//module.exports = a; exp.attr = "change"; console.log(md.exp);//{attr:"change"} 

// यदि आप बिंदु के बजाय अन्य ऑब्जेक्ट के मुकाबले बात करते हैं तो यह दूसरी ऑब्जेक्ट के लिए संपत्ति है। Md.exp खाली वस्तु होगी {}

 var a ={},md={}; exp =a; md.exp =a; exp = function(){ console.log('Do nothing...'); }; console.log(md.exp); //{} 

मैंने इस लिंक को उपरोक्त प्रश्न का उत्तर देने के लिए उपयोगी पाया।

http://timnew.me/blog/2012/04/20/exports-vs-module-exports-in-node-js/

अन्य पदों में जोड़ने के लिए नोड में मॉड्यूल सिस्टम करता है

 var exports = module.exports 

अपना कोड निष्पादित करने से पहले इसलिए जब आप निर्यात करना चाहते हैं = foo, आप शायद मॉड्यूल करना चाहते हैं। एक्सपोर्ट्स = निर्यात = फू, लेकिन export.foo = foo का उपयोग करना ठीक होना चाहिए

"यदि आप अपने मॉड्यूल के निर्यात की जड़ एक फ़ंक्शन (जैसे कन्स्ट्रक्टर) के रूप में चाहते हैं या यदि आप एक समय में एक संपत्ति बनाने के बजाए एक असाइनमेंट में एक पूर्ण ऑब्जेक्ट को निर्यात करना चाहते हैं, तो उसे इसके बजाय मॉड्यूल। निर्यात। " – http://nodejs.org/api/modules.html

डॉक्स से

निर्यात चर एक मॉड्यूल के फ़ाइल-स्तरीय दायरे में उपलब्ध है, और मॉड्यूल का मूल्यांकन होने से पहले मॉड्यूल का उपयोग किया जाता है।

यह एक शॉर्टकट की अनुमति देता है, ताकि मॉड्यूल.एक्सपोर्ट.फ़ = … को निर्यात के रूप में और अधिक संक्षिप्त रूप से लिखा जा सकता है। एफ = …. हालांकि, ध्यान रखें कि किसी भी वैरिएबल की तरह, यदि एक नया मान निर्यात को सौंपा गया है, तो यह अब मॉड्यूल के लिए बाध्य नहीं है। एक्सपोर्ट्स:

यह मॉड्यूल.एक्सपोर्ट्स के लिए केवल एक चरम बिंदु है।

1. निर्यात -> सिंगलटन उपयोगिता के रूप में उपयोग करें
2. मॉड्यूल-निर्यात -> सेवा, मॉडल आदि जैसे तार्किक वस्तुओं के रूप में उपयोग करें

चलो एक मॉड्यूल को दो तरीकों से बनाते हैं:

एक रास्ता

 var aa = { a: () => {return 'a'}, b: () => {return 'b'} } module.exports = aa; 

दूसरा तरीका

 exports.a = () => {return 'a';} exports.b = () => {return 'b';} 

और ऐसा कैसे होता है () मॉड्यूल को एकीकृत करेगा

पहला रास्ता:

 function require(){ module.exports = {}; var exports = module.exports; var aa = { a: () => {return 'a'}, b: () => {return 'b'} } module.exports = aa; return module.exports; } 

दूसरा तरीका

 function require(){ module.exports = {}; var exports = module.exports; exports.a = () => {return 'a';} exports.b = () => {return 'b';} return module.exports; } 

नोड जेएस मॉड्यूल.जेएस फ़ाइल में मॉड्यूल.लोड सिस्टम चलाने के लिए उपयोग किया जाता है। हर बार जब नोड एक फाइल निष्पादित करता है तो इसे आपके जेएस फ़ाइल सामग्री को अनुपालन के रूप में लपेटते हैं

 '(function (exports, require, module, __filename, __dirname) {',+ //your js file content '\n});' 

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

तो नोड इस लिपटे फ़ंक्शन को सी ++ का उपयोग करते हुए निष्पादित करता है उस पल में इस समारोह में पारित किए गए ऑब्जेक्ट को भर दिया जाएगा।

आप इस फ़ंक्शन मापदंडों के निर्यात और मॉड्यूल के अंदर देख सकते हैं। वास्तव में निर्यात मॉड्यूल कन्स्ट्रक्टर फ़ंक्शन का एक सार्वजनिक सदस्य है।

निम्न कोड को देखें

इस कोड को b.js में कॉपी करें

 console.log("module is "+Object.prototype.toString.call(module)); console.log("object.keys "+Object.keys(module)); console.log(module.exports); console.log(exports === module.exports); console.log("exports is "+Object.prototype.toString.call(exports)); console.log('----------------------------------------------'); var foo = require('a.js'); console.log("object.keys of foo: "+Object.keys(foo)); console.log('name is '+ foo); foo(); 

इस कोड को a.js में कॉपी करें

 exports.name = 'hello'; module.exports.name = 'hi'; module.exports.age = 23; module.exports = function(){console.log('function to module exports')}; //exports = function(){console.log('function to export');} 

अब नोड का उपयोग कर चलाएं

यह आउटपुट है

 module is [object Object] object.keys id,exports,parent,filename,loaded,children,paths {} true 

निर्यात [ऑब्जेक्ट ऑब्जेक्ट] है

object.keys of foo: नाम फ़ंक्शन है () {console.log (मॉड्यूल निर्यात करने के लिए 'फ़ंक्शन')} फ़ंक्शन मॉड्यूल निर्यात करने के लिए

अब a.js में टिप्पणी की गई पंक्ति को हटा दें और उस पंक्ति के ऊपर की रेखा टिप्पणी करें और b.js की आखिरी पंक्ति को निकाल दें और चलाएं।

जावास्क्रिप्ट की दुनिया में आप पैरामीटर के रूप में पारित ऑब्जेक्ट को पुन: असाइन नहीं कर सकते, लेकिन फ़ंक्शन के पब्लिक सदस्य को बदल सकते हैं जब उस फ़ंक्शन की ऑब्जेक्ट पैरामीटर के रूप में दूसरे फ़ंक्शन पर सेट होते हैं

की याद हैं

मॉड्यूल का उपयोग करें। एक्सपोर्ट्स और केवल तभी जब आप फ़ंक्शन प्राप्त करना चाहते हैं, जब आप कीवर्ड का उपयोग करते हैं उपरोक्त उदाहरण में हम var foo = की आवश्यकता होती है (a.js); आप देख सकते हैं कि हम एक समारोह के रूप में फू कॉल कर सकते हैं;

यह कैसे नोड प्रलेखन यह समझाता है "निर्यात ऑब्जेक्ट मॉड्यूल सिस्टम द्वारा बनाया गया है। कभी-कभी यह स्वीकार्य नहीं है, बहुत से लोग अपने मॉड्यूल को कुछ क्लास का एक उदाहरण मानते हैं। ऐसा करने के लिए इच्छित निर्यात ऑब्जेक्ट मॉड्यूल। एक्सपोर्ट्स को निर्दिष्ट करें।"

  1. दोनों module.exports exports और exports एक ही function database_module(cfg) {...} module.exports function database_module(cfg) {...} लिए इंगित करते हैं।

     1| var a, b; 2| a = b = function() { console.log("Old"); }; 3| b = function() { console.log("New"); }; 4| 5| a(); // "Old" 6| b(); // "New" 

    आप b 3 पर b को बदल सकते हैं, आउटपुट रिवर्स है। निष्कर्ष है:

    a और b स्वतंत्र हैं

  2. तो module.exports = exports = nano = function database_module(cfg) {...} के बराबर है:

     var f = function database_module(cfg) {...}; module.exports = f; exports = f; 

    ऊपर मान लिया गया है कि module.js , जो foo.js द्वारा आवश्यक है। module.exports = exports = nano = function database_module(cfg) {...} अब स्पष्ट है:

    • foo.js , क्योंकि module.exports की require('./module.js') :

       var output = require('./modules.js')(); 
    • moduls.js : आप module.exports . exports बजाय exports उपयोग कर सकते हैं।

तो, यदि आप दोनों exports और module.exports दोनों में एक ही चीज़ की ओर इशारा करते हैं तो आप खुश होंगे।