Node.js
निर्यात और खपत मॉड्यूल

Angular 2 AngularJS HTML JavaScript jQuery meteor MongoDB MySQL React TypeScript

टिप्पणियों

जबकि Node.js में सब कुछ आमतौर पर अतुल्यकालिक रूप से किया जाता है, require() उन चीजों में से एक नहीं है। चूंकि व्यवहार में मॉड्यूल को केवल एक बार लोड करने की आवश्यकता होती है, यह एक अवरुद्ध ऑपरेशन है और इसका ठीक से उपयोग किया जाना चाहिए।

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

मॉड्यूल को लोड करना और उसका उपयोग करना

require() फ़ंक्शन द्वारा एक मॉड्यूल "आयातित", या अन्यथा "आवश्यक" हो सकता है। उदाहरण के लिए, Node.js के साथ आने वाले http मॉड्यूल को लोड करने के लिए, निम्नलिखित का उपयोग किया जा सकता है:

const http = require('http');

ऐसे मॉड्यूल से जो रनटाइम के साथ शिप किए जाते हैं, आपको उन मॉड्यूल की भी आवश्यकता हो सकती है जिन्हें आपने npm से स्थापित किया है, जैसे एक्सप्रेस। यदि आपने npm install express माध्यम से पहले से ही अपने सिस्टम पर एक्सप्रेस स्थापित किया था, तो आप बस लिख सकते हैं:

const express = require('express');

आप उन मॉड्यूल को भी शामिल कर सकते हैं जिन्हें आपने अपने आवेदन के हिस्से के रूप में लिखा है। इस स्थिति में, एक फ़ाइल को lib.js नाम से एक ही निर्देशिका में वर्तमान फ़ाइल के रूप में शामिल करने के लिए:

const mylib = require('./lib');

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

const http = require('http');

// The `http` module has the property `STATUS_CODES`
console.log(http.STATUS_CODES[404]); // outputs 'Not Found'

// Also contains `createServer()`
http.createServer(function(req, res) {
  res.writeHead(200, {'Content-Type': 'text/html'});
  res.write('<html><body>Module Test</body></html>');
  res.end();
}).listen(80);

एक hello-world.js मॉड्यूल बनाना

नोड अन्य फ़ाइलों के लिए फ़ंक्शंस और चर को उजागर करने के लिए module.exports इंटरफ़ेस प्रदान करता है। ऐसा करने का सबसे सरल तरीका केवल एक ऑब्जेक्ट (फ़ंक्शन या चर) को निर्यात करना है, जैसा कि पहले उदाहरण में दिखाया गया है।

हैलो-world.js

module.exports = function(subject) {
    console.log('Hello ' + subject);
};

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

hello-venus.js: फ़ंक्शन की परिभाषा अलग से की जाती है, फिर module.exports . module.exports संपत्ति के रूप में जोड़ा जाता है
hello-jupiter.js: फ़ंक्शन परिभाषाएँ सीधे module.exports . module.exports के गुणों के मूल्य के रूप में module.exports
hello-mars.js: फ़ंक्शन परिभाषा को सीधे exports संपत्ति के रूप में घोषित किया जाता है, जो module.exports का एक छोटा संस्करण है। module.exports

हैलो-venus.js

function hello(subject) {
    console.log('Venus says Hello ' + subject);
}

module.exports = {
    hello: hello
};

हैलो-jupiter.js

module.exports = {
    hello: function(subject) {
      console.log('Jupiter says hello ' + subject);
    },

    bye: function(subject) {
      console.log('Jupiter says goodbye ' + subject);
    }
};

हैलो-mars.js

exports.hello = function(subject) {
    console.log('Mars says Hello ' + subject);
};

निर्देशिका नाम के साथ लोड हो रहा है मॉड्यूल

हमारे पास एक निर्देशिका है जिसका नाम है hello जिसमें निम्नलिखित फाइलें शामिल हैं:

index.js

// hello/index.js
module.exports = function(){
    console.log('Hej');
};

main.js

// hello/main.js
// We can include the other files we've defined by using the `require()` method
var hw = require('./hello-world.js'),
    hm = require('./hello-mars.js'),
    hv = require('./hello-venus.js'),
    hj = require('./hello-jupiter.js'),
    hu = require('./index.js');

// Because we assigned our function to the entire `module.exports` object, we
// can use it directly
hw('World!'); // outputs "Hello World!"

// In this case, we assigned our function to the `hello` property of exports, so we must
// use that here too
hm.hello('Solar System!'); // outputs "Mars says Hello Solar System!"

// The result of assigning module.exports at once is the same as in hello-world.js
hv.hello('Milky Way!'); // outputs "Venus says Hello Milky Way!"

hj.hello('Universe!'); //  outputs "Jupiter says hello Universe!"
hj.bye('Universe!'); // outputs "Jupiter says goodbye Universe!"

hu(); //output 'hej'

मॉड्यूल कैश को अमान्य करना

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

इस समस्या को हल करने के लिए, आपको कैश में प्रविष्टि को delete होगा। उदाहरण के लिए, यदि आपने एक मॉड्यूल लोड किया है:

var a = require('./a');

आप तब कैश प्रविष्टि को हटा सकते हैं:

var rpath = require.resolve('./a.js');
delete require.cache[rpath];

और फिर फिर से मॉड्यूल की आवश्यकता होती है:

var a = require('./a');

ध्यान दें कि यह उत्पादन में अनुशंसित नहीं है क्योंकि delete गए लोड किए गए मॉड्यूल के संदर्भ को delete देगा, केवल लोड किए गए डेटा को नहीं। मॉड्यूल कचरा एकत्र नहीं है, इसलिए इस सुविधा का अनुचित उपयोग मेमोरी को लीक कर सकता है।

अपने खुद के मॉड्यूल का निर्माण

आप सार्वजनिक रूप से निर्यात करने के लिए किसी वस्तु को संदर्भित कर सकते हैं और उस वस्तु के लिए लगातार तरीकों को जोड़ सकते हैं:

const auth = module.exports = {}
const config = require('../config')
const request = require('request')

auth.email = function (data, callback) {
  // Authenticate with an email address
}

auth.facebook = function (data, callback) {
  // Authenticate with a Facebook account
}

auth.twitter = function (data, callback) {
  // Authenticate with a Twitter account
}

auth.slack = function (data, callback) {
  // Authenticate with a Slack account
}

auth.stack_overflow = function (data, callback) {
  // Authenticate with a Stack Overflow account
}

इनमें से किसी का भी उपयोग करने के लिए, आपको सामान्य रूप से मॉड्यूल की आवश्यकता होगी:

const auth = require('./auth')

module.exports = function (req, res, next) {
  auth.facebook(req.body, function (err, user) {
    if (err) return next(err)

    req.user = user
    next()
  })
}

प्रत्येक मॉड्यूल को केवल एक बार इंजेक्ट किया जाता है

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

myModule.js

console.log(123) ; 
exports.var1 = 4 ;

index.js

var a=require('./myModule') ; // Output 123
var b=require('./myModule') ; // No output
console.log(a.var1) ; // Output 4
console.log(b.var1) ; // Output 4
a.var2 = 5 ; 
console.log(b.var2) ; // Output 5

नोड_मॉड्यूल से मॉड्यूल लोड हो रहा है

मॉड्यूल को एक विशेष निर्देशिका में node_modules नामक डालकर रिश्तेदार पथों का उपयोग किए बिना डी की require हो सकती require ।

उदाहरण के लिए, एक फ़ाइल index.js से foo नामक मॉड्यूल की require है, आप निम्न निर्देशिका संरचना का उपयोग कर सकते हैं:

index.js
 \- node_modules
  \- foo
   |- foo.js
   \- package.json

मॉड्यूल को एक package.json के साथ एक निर्देशिका के अंदर रखा जाना चाहिए। package.json फ़ाइल का main क्षेत्र आपके मॉड्यूल के लिए प्रवेश बिंदु को इंगित करना चाहिए - यह वह फ़ाइल है जिसे तब आयात किया जाता है जब उपयोगकर्ताओं को require('your-module') । यदि उपलब्ध नहीं है, तो index.js लिए main चूक। वैकल्पिक रूप से, आप बस के सापेक्ष पथ जोड़कर अपने मॉड्यूल के सापेक्ष फ़ाइलों का उल्लेख कर सकते require कॉल: require('your-module/path/to/file') ।

मॉड्यूल को फ़ाइल सिस्टम पदानुक्रम तक node_modules निर्देशिकाओं से d की require हो सकती require । यदि हमारे पास निम्न निर्देशिका संरचना है:

my-project
\- node_modules
 |- foo   // the foo module
  \- ...
 \- baz   // the baz module
  \- node_modules
   \- bar   // the bar module

हम require('foo') का उपयोग करके bar भीतर किसी भी फ़ाइल से मॉड्यूल foo require कर पाएंगे।

ध्यान दें कि नोड केवल उस सिस्टम से मेल खाएगा जो फाइलसिस्टम पदानुक्रम में फ़ाइल के सबसे करीब है, (फ़ाइल की वर्तमान निर्देशिका / node_modules) से शुरू होता है। नोड, फ़ाइल सिस्टम रूट तक इस तरह से निर्देशिकाओं का मिलान करता है।

आप या तो npm रजिस्ट्री या अन्य npm रजिस्ट्रियों से नए मॉड्यूल स्थापित कर सकते हैं, या अपना खुद का बना सकते हैं।

मॉड्यूल के रूप में फ़ोल्डर

मॉड्यूल को एक ही फ़ोल्डर में कई .js फ़ाइलों में विभाजित किया जा सकता है। My_module फ़ोल्डर में एक उदाहरण:

function_one.js

module.exports = function() {
  return 1;
}

function_two.js

module.exports = function() {
  return 2;
}

index.js

exports.f_one = require('./function_one.js');
exports.f_two = require('./function_two.js');

इस तरह के एक मॉड्यूल का उपयोग फ़ोल्डर नाम से इसे संदर्भित करके किया जाता है:

var split_module = require('./my_module');

कृपया ध्यान दें कि अगर आप इसे छोड़ते हुए के लिए आवश्यक ./ या समारोह तर्क की आवश्यकता से एक फ़ोल्डर के लिए पथ का कोई संकेत, नोड node_modules फ़ोल्डर से एक मॉड्यूल लोड करने के लिए कोशिश करेंगे।

वैकल्पिक रूप से आप एक ही फ़ोल्डर में एक package.json बना सकते हैं। इन सामग्रियों के साथ फाइल करें:

{
    "name": "my_module",
    "main": "./your_main_entry_point.js"
}

इस तरह से आपको मुख्य मॉड्यूल फ़ाइल "इंडेक्स" का नाम देने की आवश्यकता नहीं है।

Modified text is an extract of the original Stack Overflow Documentation

के तहत लाइसेंस प्राप्त है CC BY-SA 3.0

से संबद्ध नहीं है Stack Overflow