views:

436

answers:

5

I understand what closures are, but I am having some trouble grokking exactly what the term closure refers to. I have seen the term used in many websites, but rarely do they agree on the actual definition of it.

  • Is it the variables that are kept on the stack frame?
  • Is it the function that is being returned?
  • Is it the scope of the outer function?
  • Is it the scope of the inner (returned) function?
  • Is it maybe the concept of keeping the variables on the stack-frame after returning the function?

Can someone tell me exactly to what closure refers to?

+11  A: 

From JavaScript Closures

Two one sentence summaries:

A closure is the local variables for a function - kept alive after the function has returned, or

A closure is a stack-frame which is not deallocated when the function returns. (as if a 'stack-frame' were malloc'ed instead of being on the stack!)

A very good article on closures

Javascript Closures

A "closure" is an expression (typically a function) that can have free variables together with an environment that binds those variables (that "closes" the expression).

The simple explanation of a Closure is that ECMAScript allows inner functions; function definitions and function expressions that are inside the function bodes of other functions. And that those inner functions are allowed access to all of the local variables, parameters and declared inner functions within their outer function(s). A closure is formed when one of those inner functions is made accessible outside of the function in which it was contained, so that it may be executed after the outer function has returned. At which point it still has access to the local variables, parameters and inner function declarations of its outer function. Those local variables, parameter and function declarations (initially) have the values that they had when the outer function returned and may be interacted with by the inner function.

A good example over here

JavaScript, time to grok closures

rahul
+2  A: 

As far as I can tell, a closure is a function defined within another function that outlives the parent function's scope. A common example is callbacks:

function delay_message(msg)
{
     setTimeout(function closure() { alert(msg); }, 1000);
}

In this case, the above function closure is defined within the body of delay_message, but the function definition -- as well as the parent function's variable msg -- outlive the scope of the delay_message function call.

intgr
so you're saying that the closure <i>is</i> the inner function ?
Andreas Grech
A "closure" is the combination of a function and its state. I.e., inner function that is bound to a set of local variables from the outer function.
intgr
The inner function (`function closure`) is created at parse time, but at that point there is no closure. A closure is created as `function delay_message` executes and binds its state to `function closure`.
intgr
An anonymous function is not a closure. Please do not keep spreading this misnomer.
Mike Axiak
A: 

It's a function that "holds" a reference or references to something in another scope. For example:

var myArrayOfFunctions = [];

for(var i = 0; i<3: i++)
{
    //Note how the function being defined uses i, 
    //where i lives in the parent's scope, this creates a closure
    myArrayOfFunctions[i] = function(a) { return a + i;} 
}

myArrayOfFunctions[0](5);   //Prints 8 WTF!
myArrayOfFunctions[1](5);   //8 again
myArrayOfFunctions[2](5);   //Well, this 8 was expected

This happens because when the functions are "created", they do not copy the value of i, they hold a reference to i, so when we call the functions they use the current value of i which is 3.

Here is a graphical explanation.

Seth Illgard
Excuse my ignorance, but wouldn't it be a closure if the results were 5, 6 and 7? As far as I understand your example is precisely what's *not* a closure, but often mistaken for one. You're just defining a function and are calling it within the scope of the parent. It doesn't "enclose" the variables in the function.
deceze
I think your `CreateSum` function is incomplete...return what?
Andreas Grech
Opps, I dunno how that happened. Corrected
Seth Illgard
Even your corrected example still lacks. You're not using the `CreateSum` function at all and I think the results in your example will actually be 8, not 7.
deceze
Sorry, thats why I deleted it the first time. I have confusion on my confusion :P But it should be ok now. It should be 7 because i goes from 0 to 2.
Seth Illgard
When your loop finishes 'i' should be 3. Have you run it? :)
deceze
You got me. Corrected again and again and again.
Seth Illgard
+1  A: 

For me, the closures in JS allows you to do the following.
"a" remains available in the inner function when added to "b" although it is declared outside.

function adder(a){
  return function(b){
    return a + b;
  };
}
var add5 = adder(5);
alert( add5(10) );

For an extreme usage of JS closures, you can have a look at the source code of the PURE library (a JS templating engine)

Mic
I know what closures are for, but your answer still doesn't really refine what the `closure` really refers to
Andreas Grech
I liked this example, as it is the smaller one I know to show what a closure is, and was the most revealing for me while learning functional JS.
Mic
A: 

Essentially a closure is a function body closed over its identifiers (variables) within its local environment.

Mark Ursino