Differences between nodejs modules and their exports [closed] - node.js

Question

Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 8 years ago.
Improve this question
I was just browsing through the nodejs source and noticed differences between the ways different modules are exported. For example, some modules export an object with a prototypical inheritance style:
Thing = function () {
constructor stuff
}
Thing.prototype.jump () {
jump stuff
}
exports = Thing
Where as other modules will append functions directly to exports:
exports.spectacles = function () {
spectacle stuff
}
To me it seems that they will achieve similar goals, but they are clearly different. I believe the first example describes something like an a class, whereas the second simply makes available static methods.
What are the fundamental differences between these two approaches, how are they properly described and what are the advantages/disadvantages of one over the other?

Answer 1

Try viewing this from another perspective: the module which requires your module.
Each file in Node is a module. Each module has a global var, module, and it's property, exports. Whatever you put on that exports property will be available as the module's export.
Primitive
Ie. a boolean, number or a string will work:
module.exports = 3;
When you require that file, you'll get '3'.
var myModule = require('./my-module');
console.log(myModule); // <== 3
But since everything in JavaScript is an object, then you can call methods even a primitive prop:
console.log(myModule.toString()); // <== "3"
Function
You can also export a function.
module.exports = function() {
console.log('3 more');
};
That export will be a function:
var myModule = require('./my-module');
myModule(); // <== '3 more'
Of course, a function is also an object, so you have methods on that too to try out.
console.log(myModule.toString());
// You get: 'function (){\n console.log(\'3 more\');\n }'
Object
Then you can export an object with a few of those things:
module.exports = {
prop: 3,
method: function() {
console.log('Not 3 this time.');
}
};
When you require this module, you'll have that object - an object with a property prop and a method method.
var myModule = require('./my-module');
console.log(myModule.prop); // <== 3
myModule.method(); // <== 'Not 3 this time'
So you get the pattern? Whatever you put in module.exports is what you get on the other end. A matter of perspective, as I've said.
Default
Even if you don't export anything (ie. require an empty file), you have an export.
Require an empty file (it has to exist tho
var myModule = require('./my-module');
console.log(myModule); // <== {}
This tells you that the default export is an empty object.
This is where it gets interesting.
If module.exports = {} by default, then if we simply attach to it, we can add props to it:
So, when Node first gets your module (file), it's a {}. We can simply attach props to it.
module.exports.prop = 3;
module.exports.method = function() { console.log('I am out of ideas for placeholders, I should use kitten');}
Why does it work without the module keyword?
Now, why does this work without the module keyword? Ie. just:
exports.prop = 3;
exports.method = function() {};
Because when the Node.js starts working your file, it aliases exports to module.exports. But be careful, you can override this!
What does that mean? It's almost as if you wrote var exports = module.exports at the beginning of the file.
So you can use just the exports syntax, but I prefer not to. Why? Because you can make a mistake and override exports var. And you'll be more careful with module.exports. (There are other reasons, this one is what I have learned about first and remembered best.)
Example 1:
exports.prop = false;
// later in module
module.exports = myObj; // see? overriden.
Example 2:
var exports = {}; // see? Overridden default module.exports.
exports.prop = 4;
exports.method = function(){
console.log('3 more');
};
So when you require this later:
var myModule = require('./my-module');
console.log(myModule); // <== {}
I hope this helps.

Answer 2

The differences that you are pointing out are mainly flavour based. It is very related with how people prefer to construct their objects.
Javascript has lot's of different ways to build objects, here is another example:
exports.stuff = {
f1: function() ...
foobar: function() ...
}
For example, I prefer to wrap everything with a function to enforce use strict and simulate static variables:
(function() {
"use strict";
var staticVariable;
function MyObject() {
...
};
exports.MyObject = MyObject;
})();
+1 on close vote. This question is very subjective.