Why are self-executing anonymous functions used in Javascript Module pattern?

Question

In the module pattern in JavaScript \"Immediately-Invoked Function Expressions\" (also known as self-executing anonymous functions) are used as self executing functions that

Answer 1

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.

Answer 2

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;
})()

Answer 3

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.com/private.html