In the module pattern in JavaScript "Immediately-Invoked Function Expressions" (also known as self-executing anonymous functions) are used as self executing functions that return an object. How can a self-executing function hide private variables and only expose the returned object. Why does this not happen with a normal JavaScript function? So in the following mini module, why could we not achieve the same concept of encapsulation without the enclosing ()()?

var Module = (function () {
    var privateVariable = "foo",
        privateMethod = function () {
            alert('private method');
        };

    return {
        PublicMethod: function () {
            alert(privateVariable); 
            privateMethod(); 
        }
    };
})();

In the module pattern in JavaScript "Immediately-Invoked Function Expressions" (also known as self-executing anonymous functions) are used as self executing functions that return an object. How can a self-executing function hide private variables and only expose the returned object. Why does this not happen with a normal JavaScript function? So in the following mini module, why could we not achieve the same concept of encapsulation without the enclosing ()()?

var Module = (function () {
    var privateVariable = "foo",
        privateMethod = function () {
            alert('private method');
        };

    return {
        PublicMethod: function () {
            alert(privateVariable); 
            privateMethod(); 
        }
    };
})();

• javascript
• module
• closures

• Getting your mind around what is assigned should give you 50% of the necessary understanding. The other 50% es from an understanding of closures. If you still have trouble then read Douglas Crockford's "Private Members in JavaScript". – Beetroot-Beetroot Commented May 5, 2013 at 14:29

3 Answers 3

How can a self-executing function hide private variables and only expose the returned object. Why does this not happen with a normal JavaScript function?

It does happen with normal JavaScript functions.

function MakeModule() {
    var privateVariable = "foo",
        privateMethod = function () {
            alert('private method');
        };

    return {
        PublicMethod: function () {
            alert(privateVariable); 
            privateMethod(); 
        }
    };
}

var Module = MakeModule();

would work just fine.

The only difference is that the anonymous function introduces one less global variable and allows for itself to be garbage collected while MakeModule can't be collected unless explicitly deleted by the author.

The privateness is because of closures. The "var privateVariable" is closed over by "PublicMethod", so only that function can access the variable because only it has it in its closure. It cannot be referenced by anything else and is "private"

This happens not only in "Immediately-Invoked Function Expressions" but also in normal function calls. It is just a way to immediately create the closure when defining the module instead of doing it later when you call the outer function.

Also see this post from Douglas Crockford himself: http://javascript.crockford./private.html

You can define a anonymous function via named function.

Example:

//factorial
(function(n){
    var self = function(n){
        //call self
        return n > 0 ? (self(n-1) * n) : 1;
    }
    return self;
})()