我想要实现的是创建一个包含多个功能的模块。
模块.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);
我遇到的问题是firstParam是一个对象类型，而secondParam是一个 URL 字符串，但是当我遇到它时，它总是抱怨类型错误。
在这种情况下，如何声明多个 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
};
注意这里：
method，otherMethod你会需要这个很多您也可以使用相同的技术进行导入：
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"),
};
模块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
在您的节点模块中，您可以导出各种功能，例如：
module.exports.eat = eat;
function eat() {
.......
return *something*;
};
module.exports.sleep = sleep;
function sleep() {
.......
return *something*;
};请注意，您在导出函数时不会调用它们。然后在需要模块时，您可以要求：-
const task = require(__dirname + "/task.js");
//task is the name of the file
let eat = task.eat();
let sleep = task.sleep();如果您在模块文件中声明一个类而不是简单对象
文件：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.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
};
}());