在 Node.js 中声明多个 module.exports

您可以执行以下操作：

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

要不就：

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

然后在调用脚本中：

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

---

要导出多个函数，您可以像这样列出它们：

module.exports = {
   function1,
   function2,
   function3
}

然后在另一个文件中访问它们：

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

然后你可以通过调用来调用每个函数：

myFunctions.function1
myFunctions.function2
myFunctions.function3

---

除了@mash 答案，我建议您始终执行以下操作：

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

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

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

注意这里：

您可以从 otherMethod 调用方法，您将需要很多

您可以在需要时快速将方法隐藏为私有

这对于大多数 IDE 来说更容易理解和自动完成您的代码；）

您也可以使用相同的技术进行导入： const {otherMethod} = require('./myModule.js');

---

模块.js：

const foo = function(<params>) { ... }
const bar = function(<params>) { ... } 

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

主.js：

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

// pass your parameters
var f1 = foo(<params>);
var f2 = bar(<params>);

---

这仅供我参考，因为我试图实现的目标可以通过这个来实现。

在 module.js

我们可以做这样的事情

    module.exports = function ( firstArg, secondArg ) {

    function firstFunction ( ) { ... }

    function secondFunction ( ) { ... }

    function thirdFunction ( ) { ... }

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

    }

在 main.js

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

---

如果文件是使用 ES6 导出编写的，则可以编写：

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

---

一种方法是在模块中创建一个新对象而不是替换它。

例如：

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

并打电话

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

---

您可以编写一个在其他函数之间手动委托的函数：

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

---

有多种方法可以做到这一点，下面提到一种方法。假设你有这样的 .js 文件。

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

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

您可以使用以下代码片段导出这些函数，

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

您可以使用此代码段使用导出的函数，

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

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

我知道这是一个迟到的回复，但希望这会有所帮助！

---

用这个

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

  }
  exports.yourMethod2 =  function (success)
  {

  }


})();

---

你也可以像这样导出它

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

或者像这样的匿名函数

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

---

两种类型的模块导入和导出。

类型 1 (module.js):

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

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

类型 1（main.js）：

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

类型 2 (module.js):

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

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

类型 2（main.js）：

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

如何使用导入模块？

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

---

在您的节点模块中，您可以导出各种功能，例如：

module.exports.eat = 吃； function eat() { .. return *something*; }; module.exports.sleep = 睡眠； function sleep() { ....... return *something*; };

请注意，您在导出函数时不会调用它们。然后在需要模块时，您可以要求：-

const task = require(__dirname + "/task.js"); //task 是文件名 let eat = task.eat();让睡眠 = task.sleep();

---

模块1.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

---

如果您在模块文件中声明一个类而不是简单对象

文件：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];

主文件：index.js

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

---

你也可以使用这种方法

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

或者

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

---

在此处添加以寻求帮助：

此代码块将有助于将多个插件添加到 cypress index.js Plugins -> cypress-ntlm-auth 和 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;
};

---

使用导出关键字

module.js

export {method1, method2}

并将它们导入 main.js

import {method1, method2) from "./module"

---

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

---