CODEWITHSUNDEEP
javascriptnode.js
Andy Phillips
Andy Phillips

Reputation: 247

node.js expose variable to module?

I have read a lot of articles about how to create modules in node.js, and you can use module.exports to expose module internals to the file which includes it.. awesome!

How does this work the other way around? I'll use the following as an example :-)

USER.JS

 function User() {
   this.property = 'value';
   this.doSomething = function() {
     var getStuff = mainFileFunction();
     // do something with getStuff
 }

 module.exports = User;

MAIN.JS

 var myArray = [];
 myArray.push('something');
 myArray.push('something else');
 mainFileFunction() {
   for(thing in myArray) {
     return myArray[thing];
   }
 }

 var u = new user();

 log(u.property);  <---  THIS IS EXPOSED, COOL!

 u.doSomething();  <--- This will throw an error because mainFileFunction is not defined in user.js :-(

If I were to move mainFileFunction to the user file, then it still wouldn't work because the myArray array wouldn't be defined... and if I were to move that over too, I wouldn't be able to use it in other functions in main (which I want to) :-)

I'm sorry if I'm missing something really obvious here... What I want is to expose the parts of my choosing from modules I include (module.export works for that) but I also want to expose everything from the main file to all the includes..

or just expose everything to everything? is that totally messy and horrible??

Just to explain what I am trying to do here... I want to have classes defined in separate files, but I want to instantiate a bunch of them as objects in the main file and store them in arrays.. I want the objects to contain methods which can access arrays of the other object types.

Thanks guys! :-)

Upvotes: 5

Views: 4583

Answers (4)

alfonsodev
alfonsodev

Reputation: 2754

+1 to Benjamin answer for dependency injection. I would like to add another way to inject objects in your modules by passing the dependency in the require like require('./module.js')(dependentFunction);

//MAIN.js
var db = function() {
    this.rows = [];
    this.insert = function(name) {
        this.rows.push(name);
        console.log('Db: Inserting user with name ' + name);
    }
    this.getAll = function(){
        return this.rows;
    }
}
var fakeDb = new db();
var user = require('./user.js')(fakeDb);
user.add('Jhon');
user.add('Rose');
user.list();

and

//users.js
module.exports = function(db) {
    return {
        add: function(name) {
            db.insert(name);
        },
        list: function() {
           var users =  db.getAll();
           var i = users.length;
           console.log('listing users\n-------');
           while(i--) {
               console.log(users[i]);
           }
        }
    }
}

Upvotes: 1

Benjamin Gruenbaum
Benjamin Gruenbaum

Reputation: 276306

You can use globals, or have a proper circular dependency (requireing both files), however - this is usually a bad habit which can lead to maintainability problems in the future.

Instead, you can use dependency injection and inject doSomething into your module. This basically gives you the following for free:

  • You can test User with a simple mock implementation of doSomething later and verify the correctness of your code
  • The dependencies of a user are explicit and not implicit, which makes it obvious what a user needs.

I'll provide two implementations, one using constructor dependency injection and one with a module wide setting.

 USER.JS

 function User(dependentFunction) {
   this.property = 'value';
   this.doSomething = function() {
     var getStuff = dependentFunction();
     // do something with getStuff
   }
 }

 module.exports = User;

MAIN.JS
...
var u = new User(mainFileFunction);
u.doSomething(); // this will now work, using mainFileFunction

What happens here is fairly simple, and we know what's going on.

This can also be a module wide setting

USER.JS

function User(depFunc) {
  this.property = 'value';
  this.doSomething = function() {
    var getStuff = depFunc();
    // do something with getStuff
  }
}
function UserFactory(depFunc){ 
    return function(){
        return new User(depFunc);
    }
}
module.exports = UserFactory;

MAIN.JS

 var getUser = UserFactory(mainFileFunction);
 var u = getUser(); // will return a new user with the right function

Upvotes: 7

levi
levi

Reputation: 25111

How about moving mainFileFunction to user.js, and have the function accept an array as an argument:

mainFileFunction(array) {
   for(thing in array) {
     return array[thing];
   }
 }

And then when you call it from main.js, pass the function your array:

u.doSomething(myArray);

Upvotes: 0

Charlie Brown
Charlie Brown

Reputation: 2825

You should pass mainFileFunction as a parameter to the constructor of user.

USER.JS

 function User(mainFileFunction) {
   this.property = 'value';
   this.doSomething = function() {
     var getStuff = mainFileFunction();
     // do something with getStuff
 }

 module.exports = User;

In your main.js use the following

var u = new user(mainFileFunction);

Upvotes: 0

Related Questions