Khai báo nhiều module.exports trong Node.js

Những gì tôi đang cố gắng đạt được là tạo ra một mô-đun có chứa nhiều chức năng trong đó.

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

Vấn đề tôi gặp phải là firstParamloại đối tượng và secondParamchuỗi URL, nhưng khi tôi có nó luôn phàn nàn rằng loại đó là sai.

Làm thế nào tôi có thể khai báo nhiều module.exports trong trường hợp này?

Bạn có thể làm một cái gì đó như:

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

Hoặc chỉ:

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

Sau đó, trong tập lệnh gọi:

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

Để xuất nhiều chức năng, bạn chỉ cần liệt kê chúng như thế này:

module.exports = {
   function1,
   function2,
   function3
}

Và sau đó để truy cập chúng trong một tập tin khác:

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

Và sau đó bạn có thể gọi từng chức năng bằng cách gọi:

myFunctions.function1
myFunctions.function2
myFunctions.function3

Ngoài câu trả lời @mash, tôi khuyên bạn nên luôn luôn làm như sau:

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

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

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

Lưu ý ở đây:

• Bạn có thể gọi methodtừ otherMethodvà bạn sẽ cần điều này rất nhiều
• Bạn có thể nhanh chóng ẩn một phương thức là riêng tư khi bạn cần
• Điều này dễ hiểu hơn đối với hầu hết các IDE để hiểu và tự động hoàn tất mã của bạn;)

• Bạn cũng có thể sử dụng kỹ thuật tương tự để nhập:

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

Đây chỉ là để tôi tham khảo vì những gì tôi đã cố gắng đạt được có thể được thực hiện bằng cách này.

bên trong module.js

Chúng ta có thể làm một cái gì đó như thế này

    module.exports = function ( firstArg, secondArg ) {

    function firstFunction ( ) { ... }

    function secondFunction ( ) { ... }

    function thirdFunction ( ) { ... }

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

    }

bên trong 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>);

Nếu các tệp được ghi bằng xuất ES6, bạn có thể viết:

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

Một cách mà bạn có thể làm là tạo một đối tượng mới trong mô-đun thay vì thay thế nó.

ví dụ:

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

và để gọi

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

Bạn có thể viết một hàm ủy nhiệm thủ công giữa các hàm khác:

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

dùng cái này

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

  }
  exports.yourMethod2 =  function (success)
  {

  }


})();

Hai loại mô-đun nhập và xuất.

loại 1 (module.js):

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

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

loại 1 (main.js):

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

loại 2 (module.js):

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

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

loại 2 (main.js):

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

Làm thế nào để sử dụng mô-đun nhập khẩu?

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

bạn cũng có thể xuất nó như thế này

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

hoặc cho các chức năng ẩn danh như thế này

    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

Có nhiều cách để làm điều này, một cách được đề cập dưới đây. Chỉ cần giả sử bạn có tập tin .js như thế này.

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

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

Bạn có thể xuất các hàm này bằng đoạn mã sau,

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

Và bạn có thể sử dụng các hàm được xuất bằng đoạn mã này,

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

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

Tôi biết đây là một trả lời muộn, nhưng hy vọng điều này sẽ giúp!

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

Nếu bạn khai báo một lớp trong tệp mô-đun thay vì đối tượng đơn giản

Tệp: 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];

Tệp chính: index.js

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

Bạn cũng có thể sử dụng phương pháp này

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

hoặc là

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

Thêm vào đây để ai đó giúp đỡ:

khối mã này sẽ giúp thêm nhiều plugin vào cypress index.js Plugins -> cypress-ntlm-auth và cypress env chọn tệp

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