web-dev-qa-db-fra.com

Déclarer plusieurs module.exports dans Node.js

Ce que j'essaie de faire est de créer un module contenant plusieurs fonctions.

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

Le problème que j'ai est que la firstParam est un type d'objet et la secondParam est une chaîne d'URL, mais quand je l'ai, il se plaint toujours que le type est incorrect.

Comment puis-je déclarer plusieurs module.exports dans ce cas?

node.jsmodule
154
Ali

Vous pouvez faire quelque chose comme:

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

Ou même simplement:

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

Puis dans le programme appelant: 

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

Pour exporter plusieurs fonctions, vous pouvez simplement les lister comme ceci:

module.exports = {
   function1,
   function2,
   function3
}

Et puis pour y accéder dans un autre fichier:

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

Et ensuite, vous pouvez appeler chaque fonction en appelant:

myFunctions.function1
myFunctions.function2
myFunctions.function3
87
Devorah

Ceci est juste pour ma référence car ce que j'essayais de réaliser peut être accompli par ceci.

Dans le module.js

Nous pouvons faire quelque chose comme ça

    module.exports = function ( firstArg, secondArg ) {

    function firstFunction ( ) { ... }

    function secondFunction ( ) { ... }

    function thirdFunction ( ) { ... }

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

    }

Dans le main.js

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

Vous pouvez écrire une fonction qui délègue manuellement les autres fonctions:

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

Une façon de le faire consiste à créer un nouvel objet dans le module au lieu de le remplacer.

par exemple:

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

et d'appeler

var test = require('path_to_file').testOne:
testOne();
6
Jesse Teixeira Silva

Si les fichiers sont écrits à l'aide de l'exportation ES6, vous pouvez écrire:

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

utilisez ceci 

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

  }
  exports.yourMethod2 =  function (success)
  {

  }


})();
4
Siddharth

Deux types de module d'importation et d'exportation.

type 1 (module.js):

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

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

type 1 (main.js):

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

type 2 (module.js):

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

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

type 2 (main.js):

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

Comment utiliser le module d'importation? 

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

aussi vous pouvez l'exporter comme ça

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

ou pour des fonctions anonymes comme celle-ci

    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