Node.js में कई मॉड्यूल .exports की घोषणा करें

Question

मैं जो हासिल करने की कोशिश कर रहा हूं वह एक ऐसा मॉड्यूल बनाना है जिसमें कई कार्य हैं।

module.js:

module.exports = function(firstParam) { console.log("You did it"); },
module.exports = function(secondParam) { console.log("Yes you did it"); }, 
// This may contain more functions

main.js:

var foo = require('module.js')(firstParam);
var bar = require('module.js')(secondParam);

मेरे पास समस्या यह है कि firstParamएक ऑब्जेक्ट प्रकार है और secondParamएक URL स्ट्रिंग है, लेकिन जब मेरे पास यह है कि यह हमेशा शिकायत करता है कि प्रकार गलत है।

मैं इस मामले में कई मॉड्यूल की घोषणा कैसे कर सकता हूं।

Comments

मैं स्पष्ट रूप से इस प्रतिमान के कुछ प्रमुख भाग को याद कर रहा हूं क्योंकि यह मुझे उड़ा देता है कि इसे काम करने के लिए क्या चाहिए।

— जोशुआ पिंटर

Answer 1

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

module.exports = {
    method: function() {},
    otherMethod: function() {},
};

या केवल:

exports.method = function() {};
exports.otherMethod = function() {};

फिर कॉलिंग स्क्रिप्ट में:

const myModule = require('./myModule.js');
const method = myModule.method;
const otherMethod = myModule.otherMethod;
// OR:
const {method, otherMethod} = require('./myModule.js');

Comments

हमेशा उपयोग करें module.exports = {}और नहीं module.method = ...। stackoverflow.com/a/26451885/155740

— स्कूटी

मैं module.methodयहां कहीं भी उपयोग नहीं कर रहा हूं ... केवल exports.method, जो केवल एक संदर्भ है module.exports.method, उसी तरह व्यवहार करता है। एकमात्र अंतर यह है कि हमने परिभाषित नहीं किया है module.exports, इसलिए यह चूक करता है {}, जब तक कि मुझसे गलती न हो।

— मैश करें

@ यह उपयोग करके किसी अन्य फ़ाइल में काम करेगा var otherMethod = require('module.js')(otherMethod);:? यानी, क्या उस पंक्ति को otherMethodफ़ंक्शन की आवश्यकता होगी जैसे कि यह पृष्ठ पर एकमात्र फ़ंक्शन था और निर्यात किया गया था module.exports = secondMethod;:?

— YPCrumble

@YPCrumble आप कर सकते थे var otherMethod = require('module.js').otherMethod।

— मैश

क्या आप अन्य प्रोग्राम में मिलान की आवश्यकता दिखा सकते हैं जो उस के साथ जाएंगे?

— नीलवैल्ट्स

Answer 2

कई कार्यों को निर्यात करने के लिए आप उन्हें इस तरह सूचीबद्ध कर सकते हैं:

module.exports = {
   function1,
   function2,
   function3
}

और फिर उन्हें किसी अन्य फ़ाइल में एक्सेस करने के लिए:

var myFunctions = require("./lib/file.js")

और फिर आप प्रत्येक फ़ंक्शन को कॉल करके देख सकते हैं:

myFunctions.function1
myFunctions.function2
myFunctions.function3

Comments

सही उत्तर, यह उत्तर मुझे सही उत्तर के रूप में चिह्नित करना चाहिए।

— विष्णु रंगनाथन

आप लोगों ने कैसे इस्तेमाल किया require("./lib/file.js")? मुझे उपयोग करने की आवश्यकता है require("../../lib/file.js"), अन्यथा यह काम नहीं करेगा।

— एंटोनियो ओयो

आप उन्हें एक्सेस करते समय भी ऐसा कर सकते हैं: const { function1, function2, function3 } = require("./lib/file.js")जो आपको सीधे उन्हें कॉल करने की अनुमति देता है (उदाहरण के function1बजाय myFunctions.function1)

— डेविड यिसर

यह सबसे साफ और सरल तरीका है!

— ज़्यूस

Answer 3

@ उत्तर के अलावा मैं आपको हमेशा निम्न करने की सलाह देता हूं:

const method = () => {
   // your method logic
}

const otherMethod = () => {
   // your method logic 
}

module.exports = {
    method, 
    otherMethod,
    // anotherMethod
};

यहाँ ध्यान दें:

• आप methodसे कॉल कर सकते हैं otherMethodऔर आपको इसकी बहुत आवश्यकता होगी
• आवश्यकता पड़ने पर आप जल्दी से एक विधि को निजी रूप से छिपा सकते हैं
• अधिकांश IDE को अपना कोड समझना और स्वतः पूर्ण करना आसान है;)

• आप आयात के लिए भी इसी तकनीक का उपयोग कर सकते हैं:

  const {otherMethod} = require('./myModule.js');

Comments

ध्यान दें कि यह es6 ऑब्जेक्ट इनिशियलाइज़र शॉर्टकट का उपयोग करता है - developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

— chrismarx

यह बेहतर उत्तर imho है क्योंकि यह एक्सेस करने के तरीके को संबोधित करता है जैसे अन्य मेथोड। यह बात बताने के लिए धन्यवाद।

— जेफ बेगले

Answer 4

यह सिर्फ मेरे संदर्भ के लिए है जैसा कि मैं जो हासिल करने की कोशिश कर रहा था, उसे इससे पूरा किया जा सकता है।

में module.js

हम ऐसा कुछ कर सकते हैं

    module.exports = function ( firstArg, secondArg ) {

    function firstFunction ( ) { ... }

    function secondFunction ( ) { ... }

    function thirdFunction ( ) { ... }

      return { firstFunction: firstFunction, secondFunction: secondFunction,
 thirdFunction: thirdFunction };

    }

में main.js

var name = require('module')(firstArg, secondArg);

Answer 5

module.js:

const foo = function(<params>) { ... }
const bar = function(<params>) { ... } 

//export modules
module.exports = {
    foo,
    bar 
}

main.js:

// import modules
var { foo, bar } = require('module');

// pass your parameters
var f1 = foo(<params>);
var f2 = bar(<params>);

Answer 6

यदि फ़ाइलें ES6 निर्यात का उपयोग करके लिखी गई हैं, तो आप लिख सकते हैं:

module.exports = {
  ...require('./foo'),
  ...require('./bar'),
};

Answer 7

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

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

var testone = function () {
    console.log('test one');
};
var testTwo = function () {
    console.log('test two');
};
module.exports.testOne = testOne;
module.exports.testTwo = testTwo;

और कॉल करने के लिए

var test = require('path_to_file').testOne:
testOne();

Comments

यह अन्य उत्तरों की तुलना में मेरे लिए बहुत ही सरल दृष्टिकोण है! रियली NIce

— HN सिंह

Answer 8

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

module.exports = function(arg) {
    if(arg instanceof String) {
         return doStringThing.apply(this, arguments);
    }else{
         return doObjectThing.apply(this, arguments);
    }
};

Comments

यह फ़ंक्शन ओवरलोडिंग प्राप्त करने का एक तरीका है, लेकिन यह बहुत ... सुरुचिपूर्ण नहीं है। मुझे लगता है कि मैश का जवाब साफ है और बेहतर इरादे दिखाता है।

— नेपॉक्सक्स

Answer 9

इसे इस्तेमाल करो

(function()
{
  var exports = module.exports = {};
  exports.yourMethod =  function (success)
  {

  }
  exports.yourMethod2 =  function (success)
  {

  }


})();

Answer 10

दो प्रकार के मॉड्यूल आयात और निर्यात करते हैं।

टाइप 1 (मॉड्यूल.जेएस):

// module like a webpack config
const development = {
  // ...
};
const production = {
  // ...
};

// export multi
module.exports = [development, production];
// export single
// module.exports = development;

टाइप 1 (main.js):

// import module like a webpack config
const { development, production } = require("./path/to/module");

टाइप 2 (मॉड्यूल। जेएस):

// module function no param
const module1 = () => {
  // ...
};
// module function with param
const module2 = (param1, param2) => {
  // ...
};

// export module
module.exports = {
  module1,
  module2
}

टाइप 2 (main.js):

// import module function
const { module1, module2 } = require("./path/to/module");

आयात मॉड्यूल का उपयोग कैसे करें?

const importModule = {
  ...development,
  // ...production,
  // ...module1,
  ...module2("param1", "param2"),
};

Answer 11

भी आप इसे इस तरह से निर्यात कर सकते हैं

const func1 = function (){some code here}
const func2 = function (){some code here}
exports.func1 = func1;
exports.func2 = func2;

या इस तरह के अनाम कार्यों के लिए

    const func1 = ()=>{some code here}
    const func2 = ()=>{some code here}
    exports.func1 = func1;
    exports.func2 = func2;

Answer 12

module1.js:

var myFunctions = { 
    myfunc1:function(){
    },
    myfunc2:function(){
    },
    myfunc3:function(){
    },
}
module.exports=myFunctions;

main.js

var myModule = require('./module1');
myModule.myfunc1(); //calling myfunc1 from module
myModule.myfunc2(); //calling myfunc2 from module
myModule.myfunc3(); //calling myfunc3 from module

Answer 13

ऐसा करने के कई तरीके हैं, नीचे एक तरीका बताया गया है। बस मान लें कि आपके पास .js फ़ाइल इस तरह है।

let add = function (a, b) {
   console.log(a + b);
};

let sub = function (a, b) {
   console.log(a - b);
};

आप निम्न कोड स्निपेट का उपयोग करके इन कार्यों को निर्यात कर सकते हैं,

 module.exports.add = add;
 module.exports.sub = sub;

और आप इस कोड स्निपेट का उपयोग करके निर्यात किए गए कार्यों का उपयोग कर सकते हैं,

var add = require('./counter').add;
var sub = require('./counter').sub;

add(1,2);
sub(1,2);

मुझे पता है कि यह एक देर से जवाब है, लेकिन आशा है कि यह मदद करता है!

Answer 14

module.exports = (function () {
    'use strict';

    var foo = function () {
        return {
            public_method: function () {}
        };
    };

    var bar = function () {
        return {
            public_method: function () {}
        };
    };

    return {
        module_a: foo,
        module_b: bar
    };
}());

Answer 15

यदि आप साधारण वस्तु के बजाय मॉड्यूल फ़ाइल में एक वर्ग घोषित करते हैं

फ़ाइल: UserModule.js

//User Module    
class User {
  constructor(){
    //enter code here
  }
  create(params){
    //enter code here
  }
}
class UserInfo {
  constructor(){
    //enter code here
  }
  getUser(userId){
    //enter code here
    return user;
  }
}

// export multi
module.exports = [User, UserInfo];

मुख्य फ़ाइल: index.js

// import module like
const { User, UserInfo } = require("./path/to/UserModule");
User.create(params);
UserInfo.getUser(userId);

Answer 16

आप इस दृष्टिकोण का भी उपयोग कर सकते हैं

module.exports.func1 = ...
module.exports.func2 = ...

या

exports.func1 = ...
exports.func2 = ...

Answer 17

किसी की मदद के लिए यहां जोड़ना:

यह कोड ब्लॉक cypress index.js प्लगइन्स में कई प्लगइन्स को जोड़ने में मदद करेगा -> cypress-ntlm-cort और cypress env फ़ाइल चयन

const ntlmAuth = require('cypress-ntlm-auth/dist/plugin');
const fs = require('fs-extra');
const path = require('path');

const getConfigurationByFile = async (config) => {
  const file = config.env.configFile || 'dev';
  const pathToConfigFile = path.resolve(
    '../Cypress/cypress/',
    'config',
    `${file}.json`
  );
  console.log('pathToConfigFile' + pathToConfigFile);
  return fs.readJson(pathToConfigFile);
};

module.exports = async (on, config) => {
  config = await getConfigurationByFile(config);
  await ntlmAuth.initNtlmAuth(config);
  return config;
};