Why is closure important for JavaScript?

Question

C#'s lambda expression also has closures but is rarely discussed by the C# communities or books. I see far more JavaScript people and books talk about its closures than they do in the C# world. Why is that?

Answer 1

Because javascript doesn't have feature like namespaces, and you can mess up pretty easily with all sort of global objects.

So it is important to be able to isolate some code in its own execution environment. Closure are perfect for that.

This usage of closure doesn't make sense in a language like C# where you have namespaces, classes and so on to isolates code and not putting everything in the global scope.

A very common practice for javascript code is writting it like this :

(function(){
    // Some code
})();

As you can see, this is an anonymous function declaration, followed immediately by its execution. Thus, everything defined within the function is impossible to access from outside, and you will not mess up the global scope. The execution context of this function will remain alive as long as some code uses it, like nested functions defined within this context, that you can pass as callback or whatever.

Javascript is a very different language than C#. It's not object oriented, it is prototype oriented. This leads to very different practices at the end.

Anyway, closures are good, so use them, even in C#!

EDIT: After some discuss on stackoverflow's chat, I think this anwer has to be precised.

The function in the sample code isn't a closure. However, this fucntion can define local variable and nested functions. All nested functions that use these local variables are closures.

This is usefull to share some data across a set of functions without messing up the global scope. This is the most common use of closure in javascript.

Closure are way more powerfull than just sharing some data like this, but let's be realistic, most programmers don't know a thing about functionnal programming. In C# you would have used class or a namespace for these kind of use, but JS does not provide this functionnality.

You can do way more with closure than just protect the global scope, but this is what you'll see in JS source code.

Answer 2

Probably because popular implementations of JavaScript's object orientation depend on closures. Let's look at a simple example:

function counter() {
   var value = 0;
   this.getValue = function() { return value; }
   this.increase = function() { value++; }
}

var myCounter = new counter();
console.log(myCounter.getValue());
myCounter.increase();
console.log(myCounter.getValue());

The methods getValue and increase are in fact closures, encapsulating the variable value.

Answer 3

Because many of the libraries that make JavaScript 'bearable' use them.

Take a look at JQuery, Prototype or MooTools, just to name three popular. Each of those libraries provides an each method for their collections as the preferred way of iteration, that uses an iterator function. That function, when accessing values in the outer scope, will be a closure:

[1,2,3].each(function(item) {
   console.log(item);
});

And it does not stop there: Callbacks in Ajax, event handling in Ext.js, etc all take functions, and if you dont want to bloat your code with 100eds of functions that are called exactly once, closures are the way to go.

Answer 4

I agree with the other answers that "good" coding with JavaScript is more heavily dependent on closures. However, in addition to that, it is probably just a question of how long the feature has been around in each language. JavaScript has basically had closures since its earliest implementations. C# on the other hand has only had them since 3.0, which was released with Visual Studio 2008.

A lot of C# programmers I run into are still working on 2.0 projects. And even if they are working in 3.0 or 4.0, they often are still using 2.0 idioms. I love closures; hopefully they will become more heavily used in C# as the concept propagates among C# developers.

Answer 5

The main reason is because C# is statically typed and functions only have access to a single, predetermined environment, which impedes the usefulness of closures.

In JavaScript, on the other hand, closures enable functions to behave as methods when accessed as an object property and being first-class objects, they can also be injected into different environments which allows subroutines to operate in different contexts.

Answer 6

One reason I had to learn about them was because when you're looping through DOM elements (or anything really), you want to be able to "close" or "encapsulate" the variable scope. As in the example posted here: https://stackoverflow.com/questions/5606059/how-to-create-closure-in-loop-and-store-it-in-variable-for-later-execution