声明多个模块。在Node.js中导出

小开

最佳答案

你可以这样做:

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 = function(arg) {
if(arg instanceof String) {
return doStringThing.apply(this, arguments);
}else{
return doObjectThing.apply(this, arguments);
}
};

小开

这只是供我参考，因为我想要达到的目的可以通过这个来实现。

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

小开

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

小开

使用这个

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


}
exports.yourMethod2 =  function (success)
{


}




})();

小开

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

例如:

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 = {
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调用method，你会非常需要这个
当需要时，可以快速将方法隐藏为私有
这对于大多数IDE来说更容易理解和自动完成你的代码;)
你也可以对import使用相同的技巧:

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

小开

如果文件是用ES6导出的，你可以写:

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

小开

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

小开

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

小开

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

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

小开

你也可以像这样导出

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

< p >或对于这样的匿名函数

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

小开

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

文件: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 = ...

小开

有多种方法可以做到这一点，下面提到了一种方法。只要假设你的.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);

我知道这是一个迟到的回复，但希望这有助于!

小开

在这里加上某人的帮助:

这个代码块将帮助添加多个插件到cypress index.js 插件-> cypress-ntlm-auth和柏树环境文件选择

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

小开

使用出口关键字

module.js

export {method1, method2}

并在main.js中导入它们

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

小开

你可以像我下面做的那样…对于函数和箭头函数:

greet.js:

function greetFromGreet() {
console.log("hello from greet module...");
}


const greetVar = () => {
console.log("greet var as a arrow fn/...");
};


module.exports = { greetVar, greetFromGreet }; // ---- multiple module export...

// -----------------------------------------------

app.js:

const greetFromGreets = require("./greet");


greetFromGreets.greetFromGreet();
greetFromGreets.greetVar();

// -----------------------------------------------