Node JS 在 module.exports 中调用“本地”函数

Question

How do you call a function from within another function in a module.exports declaration?

I have MVC structure node js project and a controller called TestController.js. I want to access method within controller, but using this keyword gives below error:

cannot call method getName of undefined

"use strict"
module.exports = {
    myName : function(req, res, next) {
        // accessing method within controller
        this.getName(data);
    },

    getName : function(data) {
        // code
    }
}

How do I access methods within controller?

Answer 1

I found the solution :-)

"use strict"
var self = module.exports = {
    myName : function(req, res, next) {
        // accessing method within controller
        self.getName(data);
    },

    getName : function(data) {
        // code
    }
}

Answer 2

You can access the getName function trough module.exports . Like so:

"use strict"
module.exports = {
    myName : function(req, res, next) {
        // accessing method within controller
        module.exports.getName(data);
    },

    getName : function(data) {
        // code
    }
}

Answer 3

Maybe you could do it like this. It reduce nesting. And all your export is done at the end of your file.

"use strict";

var _getName = function() {
    return 'john';
};

var _myName = function() {
    return _getName();
};

module.exports = {
    getName : _getName,
    myName : _myName
};

Answer 4

If you want to use the function locally AND in other files...

function myFunc(){
    return 'got it'
}
module.exports.myFunc = myFunc;

Answer 5

I know the answer is already accepted, but I feel the need to add my two cents on the issue.

Node modules have a "Singletonic" nature, when inside the module, you are the module. In my opinion, at least design pattern wise, inner module methods can be accessed more cleanly, without the need for this or a copy of self for that matter.

Using this , could be dangerous, if one happens to send the separate methods around and forgets to use .bind .

Using a copy of self , is redundant, we already are inside a Singleton behaving module, why keep a reference to yourself when you can avoid that?

Consider these instead:

Option 1

// using "exports."

exports.utilityMethod = (..args) => {
     // do stuff with args
}

exports.doSomething = (someParam) => {
    // this always refers to the module
    // no matter what context you are in
    exports.utility(someParam)
}

Option 2

// using module.exports

const utility = (..args) => {
   // do stuff with args
}

const doSomething = (someParam) => {
    // Inside the module, the utility method is available
    // to all members
    utility(someParam)
}

// either this
module.exports = {
 utility,
 doSomething,
}

// or 
module.exports = {
 customNameForUtility: utility,
 customNameForDoSomething: doSomething
}

This works the same for es6 modules:

Option 1 (ES6)

export const utilityMethod = (..args) => {
     // do stuff with args
}

export const doSomething = (someParam) => {
    // this always refers to the module
    // no matter what context you are in
    utility(someParam)
}

Option 2 (ES6)

const utility = (..args) => {
   // do stuff with args
}

const doSomething = (someParam) => {
    // Inside the module, the utility method is available
    // to all members
    utility(someParam)
}

export default {
  doSomething,
  utility
}

// or 
export {
 doSomething,
  utility
}

Again, this is just an opinion, but it looks cleaner, and is more consistent across different implementations, and not a single this / self is used.