Why do we have closures in JavaScript?

Question

Am wrapping my head around JavaScript closures and am at a point where things are falling in place; i.e 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.

Am starting to understand this concept, but the more i understand the more i keep on wondering why do we have to use them.

An example like this one makes me understand the concept but leaves me asking, there is a simpler way of doing this!

function sayHello(name) {
   var text = 'Hello ' + name;
   var sayAlert = function() { alert(text); }
   sayAlert();
}
sayHello('Gath');

Am just wondering why do i have to keep local variable alive? after the function has exited?

Where can i get examples showing of solutions implemented by closure and that nothing else would have worked but closures?

Answer 1

The example you chose appears on this page, so I assume you took it from there. Have you looked at all the other examples it provides? They explain the motivations for closures better than I possibly could.

Answer 2

A closure is a function with all the environnement needed for it to be executed. In javascript, it's when an anonymous function (= lambda) is created, using a variable from an outer scope.

You can better understand why with a code like that:

function foo()
{
  var text = computeFromOutside();
  // ... other lines of code
  return function(otherText) { return text + otherText; }
}

bar = foo();

function baz(fun)
{
  return fun("some text");
}

Here, you are returning a function that uses the local variable "text". Therefore, you are leaving the foo function scope, destroying its variables. However, since we have an anonymous function using text, we must keep a track of this variable. This can be achieved by value or by reference, depending on the language (Keeping the variable alive (with the possibility to modify it afterwards, or copying its value when the function is created)).

I hope this helps !

Answer 3

Closures add expressive power to the language. There are some patterns that can be implemented very easily because of closures. A few examples that come to mind include:

• The Module Pattern - Example by Eric Miraglia
• Memoization - Example by Oliver Steele
• Currying - Example by Dustin Diaz

Answer 4

A normal function does its thing, computes a result and returns it. By returning a closure, you can package off your work part-way through, and let callers get more when they are ready for it. Since I tried Scheme at university, I've been hankering for closures in every language I've worked with since... they're dangerously habit-forming!

They are also arguably an important part of the future: along with other functional programming mechanism that seem a good fit for parallel programming of multi-core systems.

Answer 5

check out article from EFNet #javascript FAQ