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?
Source: Tips4all
From JavaScript Closures
ReplyDeleteTwo 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
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:
ReplyDeletefunction 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.
For me, the closures in JS allows you to do the following.
ReplyDelete"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)
Essentially a closure is a function body closed over its identifiers (variables) within its local environment.
ReplyDeleteIt's a function that "holds" a reference or references to something in another scope. For example:
ReplyDeletevar 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.
A closure is a function value created from a nested function declaration or function expression (i.e. lambda expression) whose body contains one or more references to variables declared in an outer (but not global) scope.
ReplyDelete