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

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?

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

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

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

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

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

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

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

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

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

utilizar este

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

  }
  exports.yourMethod2 =  function (success)
  {

  }


})();

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

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;

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

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!

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

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

Puedes usar este enfoque también

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

o

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

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