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?

  • 3
    Because JavaScript is treated as first class functional language and C# is a classical OOP langauge. Different paradigms, different programming styles.
    – Raynos
    Commented Jun 30, 2011 at 9:59
  • 1
    Having first class function does make the language a functionnal language. PHP (since 5.3), python or D has first class function. Would you say that they are functionnal languages ? Certainly not, and javascript either.
    – deadalnix
    Commented Jun 30, 2011 at 10:46
  • 1
    @deadalnix JavaScript is a multi-paradigm language. It mainly supports the procedural, functional and prototypical OO paradigm. It's by no means a pure functional language, but you can easily write javascript in the functional paradigm without bending the language. I would say the same of C# and python.
    – Raynos
    Commented Jun 30, 2011 at 10:50
  • 3
    @deadalnix, a language which allows you to define a Y-combinator is a functional language. By definition.
    – SK-logic
    Commented Jun 30, 2011 at 13:01
  • 1
    @deadalnix: I suppose what it comes down to is the question what approaches are promoted by the language. There's many JavaScript frameworks and platforms (notably node.js and DOM (event model)) that rely heavily on first order functions. PHP does have the features that allow for the very same programming style, but if you take a look at the standard API or many frameworks, then you see it's not really at the core of the language.
    – back2dos
    Commented Jun 30, 2011 at 13:59

6 Answers 6


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 :

    // 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.

  • 9
    That's not a closure. You descriping the advantage of using functions to create local scope.
    – Raynos
    Commented Jun 30, 2011 at 10:00
  • 2
    a closure is only a closure if it closes over free variables. Also thank you for telling me I don't know how JavaScript works :)
    – Raynos
    Commented Jun 30, 2011 at 10:32
  • 2
    rather then resorting to undermining me by calling me a beginner feel free to put forward actual arguments in the JavaScript SO Chat room. This discussion doesn't really belong here, but I'll happily discuss your misconceptions in the SO chat.
    – Raynos
    Commented Jun 30, 2011 at 10:40
  • 1
    Downvoted. JavaScript is plenty object oriented. It's just not class-based but such functionality is easily authored. It has first class functions, takes advantage of closures to make it a natural fit for heavily event-driven paradigms, and a chief source of inspiration according to its author, Brendan Eich, was Scheme. I'm not really sure what you think a functional language is, but the funny part is that you seem to think class-based inheritance is somehow critical rather than no longer entirely necessary when you can pass functions around and apply them in new contexts. Commented Aug 12, 2011 at 8:01
  • 2
    -1 as well. This does not describe closures, it describes scope.
    – Izkata
    Commented Jul 31, 2013 at 17:07

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

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

  • 3
    -1 "depends on closures" That's highly subjective. It does not.
    – Raynos
    Commented Jun 30, 2011 at 10:32
  • Raynos: care to show us how to create and use private members without closures?
    – user281377
    Commented Jun 30, 2011 at 11:05
  • 1
    @ammoQ there is no such thing as private in JavaScript. What you meant was "because JavaScript classical OO emulation depends on closures". JavaScript OO is prototypical which is a different paradigm. It's a good answer to the question though, "We use closures in JavaScript because there needed to emulate classical OO"
    – Raynos
    Commented Jun 30, 2011 at 11:33
  • 1
    @keppla I meant "OO depends on closures" is subjective. You don't need closures for OO at all.
    – Raynos
    Commented Jun 30, 2011 at 13:02
  • 2
    you're exposing me as the rep whore I am...
    – user281377
    Commented Jun 30, 2011 at 14:44

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) {

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.

  • 1
    Why is it not a closure? console.log is definied in an outer scope, so console is a 'free variable'. And, why is, in effect, a for-loop, which does nothing different, a bad practice?
    – keppla
    Commented Jun 30, 2011 at 12:56
  • @Raynos: my definition of closure is 'block that contains a free variable', it does not loose that status, it the free variable happens to be on top scope. But, to support my point, consider this method: pastie.org/2144689 . Why should this be bad?
    – keppla
    Commented Jun 30, 2011 at 13:06
  • I still think "closing" over global data is considered cheating. I agree that accessing data up the scope chain is fine, it's simply good practice to minimise that access.
    – Raynos
    Commented Jun 30, 2011 at 13:10
  • Agreed on minimise access
    – keppla
    Commented Jun 30, 2011 at 13:10
  • It should be noted that with array iterators (forEach, map, reduce, etc) there is zero reason for them to be closures, they have all the state passed into them directly. I would consider it an anti pattern for them to be closures
    – Raynos
    Commented Mar 31, 2012 at 0:40

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.


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.

  • 1
    What does static typing have to do with this? Closures are orthogonal.
    – user39685
    Commented Jul 31, 2013 at 14:49

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

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.