JavaScript module pattern vs Constructor with methods defined in constructor

Question

From a single instance and a multiple instance point of view, why would I write all those extra lines of code following the Module Pattern vs just using a standard Constructor with methods and properties defined in the constructor body?

Module Pattern sample : http://jsfiddle.net/T3ZJE/1/

var module = (function () {
    // private variables and functions
    var foo = 'bar';

    // constructor
    var module = function () {
    };

    // prototype
    module.prototype = {
        constructor: module,
        something: function () {
        }
    };

    // return module
    return module;
})();

var my_module = new module();

console.log(my_module)

Constructor sample : http://jsfiddle.net/EuvaS/2/

function Module(){

    // private variables and functions
    var foo = 'bar';

    //public methods
    this.something = function () {

    }        
}

var my_module = new Module();

console.log(my_module);

To me the end result is pretty much the same. Both can have public properties and methods, both can have "private" variables and methods which can be accessed by the public methods.

Both will define public / prototype methods once for a singleton, both will define them multiple times for multiple instances / clones of the object.

Am I missing something? What is the difference?

Damp · Accepted Answer · 2012-11-28 18:48:13Z

18

In the first example, foo will be a static variable common to all instances of module(). Meaning, all instances will reference the same variable.

In the second example, foo is different for each Module() instance.

Apart from that, I don't see any difference.

answered Nov 28, 2012 at 18:48

Damp

3,34823 silver badges19 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

Fergal Over a year ago

That is indeed one important difference.

Fergal Over a year ago

For poops and giggles, this slight modification to the Constructor method will create static private vars AND only define our public methods once while allowing them access all private vars in the Constructor scope: jsfiddle.net/zHwQX/2

Damp Over a year ago

@Fergal good point, didn't see that either. So I guess overall, more functionality and smaller memory footprint

BBaysinger Over a year ago

@Fergal Is jsfiddle.net/zHwQX/2 something you made, or is that a common pattern?

David Lee · Accepted Answer · 2012-11-28 19:03:28Z

0

Nothing special difference. But I am not sure what is the point of the module pattern in this example. You don't need to include the constructor in the module. Constructors should be used like the second style. But it is better for the methods to be defined in its prototype object unless you need to have it for each instance.

Again in terms of purpose, I do not think that the module pattern here is proper way.

answered Nov 28, 2012 at 19:03

David Lee

113 bronze badges

2 Comments

Fergal Over a year ago

I got that snippet from here:briancray.com/posts/javascript-module-pattern

David Lee Over a year ago

@Fergal Well, I am not sure if his opinion is proper for the pattern. As you mentioned in your question having constructor in the module is extra work which is unnecessary, I think. I can't find any merit.

Collectives™ on Stack Overflow

JavaScript module pattern vs Constructor with methods defined in constructor

2 Answers 2

4 Comments

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

4 Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related