Structuring a NodeJS module - variables and methods

Question

I want to create modules to structure my NodeJS application, but I'm a little lost, and I haven't found anything (with hours of searching) that is completely definitive on the subject.

Say I'd like to create a "user" module, from which I can create new users in my code using something like:

var newUser = new User(); 

Ideally, I'd require my module at the top of my code using something like:

var User = require('../lib/user'); 

This works great. The question is, how should I structure the user module? Is the following the best way?

module.exports = function User()    {     var authorized = false;     var username = undefined;     var password = undefined;     var statistics = undefined;      this.authorized = function()  {         return authorized;     }     this.username = function()  {         return username;     }     this.statistics = function()    {         return statistics;     } } 

I'm writing getters and setters for my various module variables, allowing me to hide things I don't want to accidentally access from other code. However, I have done it this way before:

function User() {     this.authStatus = false;     this.email;     this.displayName;     this.inSession; }  User.prototype.isAuthenticated = function() {     return(this.authStatus && this.email && this.displayName) }  User.prototype.isInSession = function() {     return(this.inSession && this.isAuthenticated()); }  exports.User = User; 

This works too, with one caveat; I haven't found a way to access the user properties from within closures. If my understanding is correct, with the second implementation, I can't. This means if I need to hand a function off to a db library as a callback to edit the user's properties, I can't. That'd look something like:

User.prototype.login = function()    {     db.doDbStuff('get user data query', function(_error, _result)    {          this.username = _result[0].name; //this code will not work     }); } 

The code doesn't work, to my understanding, because the "this" keyword is within the scope of the closure, not the User. Even if the code were to be placed within the User function:

function User() {     this.login = function()    { //you know 

It wouldn't work.

I guess my question is, what's the best solution to this problem? Is it the method I presented in the first code block? That seems rather cumbersome and messy and prone to variable collision. I'm scared.

Thanks in advance!

Answer 1

I typically go with the second approach, attaching functions to the prototypes.

The issue you're having with variables "not being available in closures" has nothing to do with prototypes. You'd have that same issue either way you structure it.

It's to do with javascript's oft-confusing dynamic this: http://robotlolita.me/2011/10/09/understanding-javascript-oop.html#sec-2-1

Basically, you need to do something like:

User.prototype.login = function()    {     var self = this // bind this to self so you have a reference to what `this` was      db.doDbStuff('get user data query', function(_error, _result)    {          self.username = _result[0].name; // self refers to the original `this`, so this works.     }); } 

You also have the option of using function.bind: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/bind

Within the bound function, the value of this will be whatever value you provided to .bind(value):

User.prototype.login = function()    {     db.doDbStuff('get user data query', (function(_error, _result)    {           this.username = _result[0].name; // bind fixes the original `this`, so this also works.     }).bind(this)); } 

Whether you use function.bind or self = this is somewhat of a personal taste question, but we were doing some benchmarks in the freenode#nodejs the other day and discovered bind() is 20 something times slower than var self = this.

As to your original question about how to structure modules, there are so many examples to learn from on github. Simply find your favourite module and inspect how they structure it. I notice that many people seem to prefer factories over exposing constructors directly (e.g. require('module').create() ). Your call.