Node.js에서 여러 module.exports 선언

Node.js에서 여러 module.exports 선언

---

내가 달성하려는 것은 여러 기능을 포함하는 하나의 모듈을 만드는 것입니다.

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는 객체 유형이고 secondParamURL 문자열이라는 것이지만, 가지고있을 때 항상 유형이 잘못되었다고 불평합니다.

이 경우 여러 module.exports를 어떻게 선언 할 수 있습니까?

---

당신은 다음과 같은 것을 할 수 있습니다 :

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

아니면 그냥 :

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

그런 다음 호출 프로그램에서 :

var MyMethods = require('./myModule.js');
var method = MyMethods.method;
var otherMethod = MyMethods.otherMethod;

---

여러 함수를 내보내려면 다음과 같이 나열하면됩니다.

module.exports = {
   function1,
   function2,
   function3
}

그런 다음 다른 파일로 액세스하십시오.

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

그리고 다음을 호출하여 각 함수를 호출 할 수 있습니다.

myFunctions.function1
myFunctions.function2
myFunctions.function3

---

@mash 답변 외에도 항상 다음을 수행하는 것이 좋습니다.

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

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

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

여기에 참고하십시오 :

• 당신은 전화 method를 할 수 otherMethod있고 당신은 이것을 많이 필요로 할 것입니다
• 필요할 때 메소드를 비공개로 빠르게 숨길 수 있습니다
• 이것은 대부분의 IDE가 코드를 이해하고 자동 완성하는 것이 더 쉽습니다.)

• 가져 오기에 동일한 기술을 사용할 수도 있습니다.

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

---

이것은 내가 달성하려고했던 것이 이것에 의해 달성 될 수 있기 때문에 단지 참조 용입니다.

에서 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);

---

파일이 ES6 내보내기를 사용하여 작성된 경우 다음을 작성할 수 있습니다.

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

---

이를 수행 할 수있는 한 가지 방법은 모듈을 교체하지 않고 새 객체를 작성하는 것입니다.

예를 들면 다음과 같습니다.

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();

---

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>);

---

다른 함수간에 수동으로 위임하는 함수를 작성할 수 있습니다.

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

---

이것을 사용하십시오

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

  }
  exports.yourMethod2 =  function (success)
  {

  }


})();

---

두 가지 유형의 모듈 가져 오기 및 내보내기

유형 1 (module.js) :

// 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.js) :

// 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"),
};

---

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

---

또한 당신은 이것을 이렇게 내보낼 수 있습니다

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;

---

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
    };
}());

참고URL : https://stackoverflow.com/questions/16631064/declare-multiple-module-exports-in-node-js