First, let’s define 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). - Jim Ley
- Simply put, a closure is a variable, created inside a function, which continues to exist after the function has finished executing. - Patrick Hunlock
- global object and global scope
- reference types and primitive types
- lexical scope and the scope chain
- the call object or the ECMA activation object
- idea of persistent data
- private variables
- using return
To begin, we want to create a reusable function containing data that persists across invocations.
We don’t want to hard code variables into the reusable function, and a local variable will not persist.
So instead, we want the developer to make two calls: One, to set up or ‘configure’ the function, and two, to invoke this ‘pre-configured’ function.
The power is in the first call. I like to refer to it as the configuration call.
During the configuration call, we ‘freeze’ the inner function by setting a reference to it in the global scope.
So this data persists. Why?
We have an external reference to this inner function.
The inner nested function retains its reference to the call object of the outer function.
The outer function’s local scope resolves and the reference to its inner function remains.
This is an example from a friend that helped me finally wrap my head around the power of the technique.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25