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?

Answer 1

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.