Declarar exportaciones de módulos múltiples en Node.js

244

Lo que intento lograr es crear un módulo que contenga múltiples funciones.

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

El problema que tengo es que firstParames un tipo de objeto y secondParames una cadena de URL, pero cuando lo tengo, siempre se queja de que el tipo es incorrecto.

¿Cómo puedo declarar exportaciones de módulos múltiples en este caso?

Ali
fuente
2
Claramente me estoy perdiendo alguna parte clave de este paradigma porque me sorprende lo que se necesita para que esto funcione.
Joshua Pinter

Respuestas:

541

Puedes hacer algo como:

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

O solo:

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

Luego, en el script de llamada:

const myModule = require('./myModule.js');
const method = myModule.method;
const otherMethod = myModule.otherMethod;
// OR:
const {method, otherMethod} = require('./myModule.js');
mezcla
fuente
25
Siempre use module.exports = {}y no module.method = .... stackoverflow.com/a/26451885/155740
Scotty
99
No estoy usando module.methodningún lugar aquí ... solo exports.method, que es solo una referencia module.exports.method, por lo que se comporta de la misma manera. La única diferencia es que no definimos module.exports, por lo que por defecto es {}, a menos que me equivoque.
puré
@mash funcionaría esto en otro archivo usando var otherMethod = require('module.js')(otherMethod);:? Es decir, ¿esa línea requeriría la otherMethodfunción como si fuera la única función en la página y la exportación hubiera sido module.exports = secondMethod;:?
YPCrumble
3
@YPCrumble que podrías hacer var otherMethod = require('module.js').otherMethod.
puré
¿Puedes mostrar las coincidencias requeridas en el otro programa que iría con eso?
NealWalters
138

Para exportar múltiples funciones, simplemente puede enumerarlas así:

module.exports = {
   function1,
   function2,
   function3
}

Y luego para acceder a ellos en otro archivo:

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

Y luego puede llamar a cada función llamando:

myFunctions.function1
myFunctions.function2
myFunctions.function3
Devorah
fuente
1
Respuesta perfecta, esta respuesta debería estar marcada como la respuesta correcta.
Vishnu Ranganathan
¿Cómo lo usaron ustedes require("./lib/file.js")? Necesito usar require("../../lib/file.js"), de lo contrario no funcionará.
Antonio Ooi el
11
También puede hacer esto al acceder a ellos: lo const { function1, function2, function3 } = require("./lib/file.js")que le permite llamarlos directamente (por ejemplo, en function1lugar de myFunctions.function1)
David Yeiser
¡Este es el enfoque más limpio y simple!
Zeus
43

Además de la respuesta @mash, te recomiendo que hagas siempre lo siguiente:

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

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

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

Nota aquí:

  • Puede llamar methoddesde otherMethody lo necesitará mucho
  • Puede ocultar rápidamente un método como privado cuando lo necesite
  • Esto es más fácil para la mayoría de los IDE de comprender y completar automáticamente su código;)
  • También puede usar la misma técnica para importar:

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

Alnamrouti Fareed
fuente
Tenga en cuenta que esto utiliza el acceso directo al inicializador de objetos es6 - developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
chrismarx
1
Esta es la mejor respuesta en mi humilde opinión, ya que aborda el método de acceso de otro método. Gracias por señalar eso.
Jeff Beagley
15

Esto es solo para mi referencia, ya que lo que estaba tratando de lograr se puede lograr con esto.

En el module.js

Podemos hacer algo como esto

    module.exports = function ( firstArg, secondArg ) {

    function firstFunction ( ) { ... }

    function secondFunction ( ) { ... }

    function thirdFunction ( ) { ... }

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

    }

En el main.js

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

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>);
Anthony Awuley
fuente
8

Si los archivos se escriben utilizando la exportación ES6, puede escribir:

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

Una forma de hacerlo es creando un nuevo objeto en el módulo en lugar de reemplazarlo.

por ejemplo:

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

y llamar

var test = require('path_to_file').testOne:
testOne();
Jesse Teixeira
fuente
¡Esto me pareció un enfoque muy simple en comparación con otras respuestas! Realmente agradable
HN Singh
6

Puede escribir una función que delegue manualmente entre las otras funciones:

module.exports = function(arg) {
    if(arg instanceof String) {
         return doStringThing.apply(this, arguments);
    }else{
         return doObjectThing.apply(this, arguments);
    }
};
icktoofay
fuente
Esta es una forma de lograr la sobrecarga de funciones, pero no es muy ... elegante. Creo que la respuesta de Mash es más limpia y muestra mejor la intención.
Nepoxx
5

utilizar este

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

  }
  exports.yourMethod2 =  function (success)
  {

  }


})();
Siddharth
fuente
3

Módulo de dos tipos de importación y exportación.

tipo 1 (module.js):

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

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

tipo 1 (main.js):

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

tipo 2 (module.js):

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

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

tipo 2 (main.js):

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

¿Cómo usar el módulo de importación?

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

también puedes exportarlo así

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

o para funciones anónimas como esta

    const func1 = ()=>{some code here}
    const func2 = ()=>{some code here}
    exports.func1 = func1;
    exports.func2 = func2;
bahri noredine
fuente
2

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
Puria jahanbani
fuente
2

Hay varias formas de hacer esto, una de ellas se menciona a continuación. Solo asume que tienes un archivo .js como este.

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

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

Puede exportar estas funciones utilizando el siguiente fragmento de código,

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

Y puede usar las funciones exportadas usando este fragmento de código,

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

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

Sé que esta es una respuesta tardía, ¡pero espero que esto ayude!

Achintha Isuru
fuente
0
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
    };
}());
balthazarbux
fuente
0

Si declara una clase en el archivo de módulo en lugar del objeto simple

Archivo: 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];

Archivo principal: index.js

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

Puedes usar este enfoque también

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

o

exports.func1 = ...
exports.func2 = ...
Bogdan Surai
fuente
0

Agregando aquí para que alguien ayude:

este bloque de código ayudará a agregar múltiples complementos en cypress index.js Plugins -> selección de archivos cypress-ntlm-auth y 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;
};
testtek
fuente