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 das firstParamein Objekttyp und das secondParameine URL-Zeichenfolge ist, aber wenn ich das habe, beschwert es sich immer, dass der Typ falsch ist.

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

Sie können so etwas tun wie:

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

Oder nur:

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

Dann im aufrufenden Skript:

const myModule = require('./myModule.js');
const method = myModule.method;
const otherMethod = myModule.otherMethod;
// OR:
const {method, otherMethod} = require('./myModule.js');

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

module.exports = {
   function1,
   function2,
   function3
}

Und dann, um in einer anderen Datei darauf zuzugreifen:

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

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

myFunctions.function1
myFunctions.function2
myFunctions.function3

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 anrufen methodaus otherMethodund Sie werden diese viel brauchen
• Sie können eine Methode bei Bedarf schnell als privat ausblenden
• Dies ist für die meisten IDEs einfacher, Ihren Code zu verstehen und automatisch zu vervollständigen;)

• Sie können dieselbe Technik auch für den Import verwenden:

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

Dies ist nur als Referenz, da das, was ich erreichen wollte, dadurch erreicht werden kann.

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

    }

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

Eine Möglichkeit, dies zu tun, besteht darin, ein neues Objekt im Modul zu erstellen, anstatt es zu ersetzen.

beispielsweise:

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

und anzurufen

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

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

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

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

benutze das

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

  }
  exports.yourMethod2 =  function (success)
  {

  }


})();

Import und Export von Modulen mit zwei Typen.

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 verwende ich das Importmodul?

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

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;

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

Es gibt mehrere Möglichkeiten, dies zu tun. Eine Möglichkeit wird unten erwähnt. Nehmen Sie einfach an, Sie haben eine solche .js-Datei.

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

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

Sie können diese Funktionen mit dem folgenden Codeausschnitt exportieren:

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

Und Sie können die exportierten Funktionen mit diesem Code-Snippet verwenden.

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

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

Ich weiß, dass dies eine späte Antwort ist, aber ich hoffe, das hilft!

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

Wenn Sie eine Klasse in einer Moduldatei anstelle des einfachen Objekts deklarieren

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

Hauptdatei: index.js

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

Sie können diesen Ansatz auch verwenden

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

oder

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

Hier hinzufügen, damit jemand hilft:

Dieser Codeblock hilft beim Hinzufügen mehrerer Plugins zu cypress index.js Plugins -> Auswahl der Datei cypress-ntlm-auth und 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;
};