it-swarm.com.de

Deklarieren Sie mehrere module.exports in Node.js

Ich versuche, ein Modul zu erstellen, das mehrere Funktionen enthält.

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

Das Problem, das ich habe, ist, dass die Variable firstParam ein Objekttyp ist und die Variable secondParam eine URL-Zeichenfolge ist, aber wenn ich das habe, beschwert sie sich immer darüber, dass der Typ falsch ist.

Wie kann ich in diesem Fall mehrere module.exports deklarieren?

154
Ali

Sie können so etwas tun:

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

Oder auch nur:

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

Dann im aufrufenden Programm: 

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

Um mehrere Funktionen zu exportieren, können Sie sie wie folgt auflisten:

module.exports = {
   function1,
   function2,
   function3
}

Und dann auf sie in einer anderen Datei zugreifen:

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

Und dann können Sie jede Funktion aufrufen, indem Sie Folgendes aufrufen:

myFunctions.function1
myFunctions.function2
myFunctions.function3
87
Devorah

zusätzlich zu @mash answer empfehle ich Ihnen, immer Folgendes zu tun:

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

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

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

Beachten Sie hier:

  • Sie können method von otherMethod aufrufen, und Sie werden dies viel brauchen
  • Sie können eine Methode bei Bedarf schnell als privat ausblenden
  • Dies ist für die meisten IDEs einfacher, den Code zu verstehen und automatisch zu vervollständigen.
  • Sie können dieselbe Technik auch für den Import verwenden:

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

31

Dies ist nur ein Hinweis, da ich damit erreichen kann, was ich erreichen wollte.

Im module.js

Wir können so etwas tun

    module.exports = function ( firstArg, secondArg ) {

    function firstFunction ( ) { ... }

    function secondFunction ( ) { ... }

    function thirdFunction ( ) { ... }

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

    }

Im main.js

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

Sie können eine Funktion schreiben, die manuell zwischen den anderen Funktionen delegiert:

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

Sie können dies unter anderem tun, indem Sie ein neues Objekt im Modul erstellen, anstatt es zu ersetzen.

zum Beispiel:

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

und anrufen

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

Wenn die Dateien mit dem ES6-Export geschrieben werden, können Sie Folgendes schreiben:

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

benutze das 

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

  }
  exports.yourMethod2 =  function (success)
  {

  }


})();
4
Siddharth

Zwei Arten Modulimport und -export.

typ 1 (module.js):

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

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

typ 1 (main.js):

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

typ 2 (module.js):

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

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

typ 2 (main.js):

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

Wie Importmodul verwenden?

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

sie können es auch so exportieren

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

oder für anonyme Funktionen wie diese

    const func1 = ()=>{some code here}
    const func2 = ()=>{some code here}
    exports.func1 = func1;
    exports.func2 = func2;
1
bahri noredine
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
    };
}());
0
balthazarbux

module.js:

const foo = function(firstParam) { ... }
const bar = function(secondParam) { ... } 

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

main.js:

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

// pass your parameters
var f1 = foo(firstParam);
var f2 = bar(secondParam);
0
Anthony Awuley

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
0
Puria jahanbani