Question

Possible Duplicate:
What advantages does using (function(window, document, undefined) { … })(window, document) confer?

I’m increasingly seeing code like this in libraries I’ve been using:

(function (window) {
    var Foo = function () {
    }

    window.Foo = Foo;
})(window);

The argument I’ve seen for doing this is to avoid working in the global scope when creating (pseudo) classes. But, correct me if I’m wrong, I always understood that window IS the global scope. I believe, when you create a global variable, you are really only adding a property to window anyway… Unless this is changing for ES5 strict?

So, basically, what’s the point? The only benefit I can see to code organised like this is if you wanted to easily change the namespace of your classes at a later date by passing in an argument other than window.

Answer 1

Infact, strict mode throws an exception if you forget to use var for any variable declaration. But that works even without using an outer closure.

Using this pattern is much more for protecting yourself from the outside javascript world. For instance, some other script overwrites window.undefined or any other variable, you can grab the value within that closure to savely access it from within.

For instance

(function _myApp( win, doc, undef ) {
    // app code
}( this, this.document ));

Also, when declaring variables with var, or creating function declarations, those are always stored within the current Activation Object respectively the Lexical Environment Record. That means, without using a Function context, you can easily overwrite methods and variables from some other point, because all of those would get stored in the current Context (which would be the global one)

So:

(function _myApp( win, doc, undef ) {
    var myVar = 42;

    function myFunc() {
    }
}( this, this.document ));

(function _myModule( win, doc, undef ) {
    var myVar = 42;

    function myFunc() {
    }
}( this, this.document ));

This works because of closure and Context, but if you would use the same code, without the Function Context, we would obviously overwrite our myVar and myFunc. This could happen from everywhere, within the same file or in another loaded script.