How do JavaScript closures work?

How would you explain JavaScript closures to someone with a knowledge of the concepts they consist of (for example functions, variables and the like), but does not understand closures themselves?

I have seen the Scheme example given on Wikipedia, but unfortunately it did not help.

A closure is a pairing of:

• A function and

• A reference to that function's outer scope (lexical environment)

A lexical environment is part of every execution context (stack frame) and is a map between identifiers (i.e. local variable names) and values.

Every function in JavaScript maintains a reference to its outer lexical environment. This reference is used to configure the execution context created when a function is invoked. This reference enables code inside the function to "see" variables declared outside the function, regardless of when and where the function is called.

If a function was called by a function, which in turn was called by another function, then a chain of references to outer lexical environments is created. This chain is called the scope chain.

In the following code, inner forms a closure with the lexical environment of the execution context created when foo is invoked, closing over variable secret:



function foo() {
const secret = Math.trunc(Math.random() * 100)
return function inner() {
console.log(The secret number is ${secret}.)
}
}
const f = foo() // secret is not directly accessible from outside foo
f() // The only way to retrieve secret is to invoke f`



In other words: in JavaScript, functions carry a reference to a private "box of state", to which only they (and any other functions declared within the same lexical environment) have access. This box of the state is invisible to the caller of the function, delivering an excellent mechanism for data-hiding and encapsulation.

And remember: functions in JavaScript can be passed around like variables (first-class functions), meaning these pairings of functionality and state can be passed around your program, similar to how you might pass an instance of a class around in C++.

If JavaScript did not have closures, then more states would have to be passed between functions explicitly, making parameter lists longer and code noisier.

So, if you want a function to always have access to a private piece of state, you can use a closure.

...and frequently we do want to associate the state with a function. For example, in Java or C++, when you add a private instance variable and a method to a class, you are associating the state with functionality.

In C and most other common languages, after a function returns, all the local variables are no longer accessible because the stack-frame is destroyed. In JavaScript, if you declare a function within another function, then the local variables of the outer function can remain accessible after returning from it. In this way, in the code above, secret remains available to the function object inner, after it has been returned from foo.
Uses of Closures

Closures are useful whenever you need a private state associated with a function. This is a very common scenario - and remember: JavaScript did not have a class syntax until 2015, and it still does not have a private field syntax. Closures meet this need.
Private Instance Variables

In the following code, the function toString closes over the details of the car.



function Car(manufacturer, model, year, color) {
return {
toString() {
return ${manufacturer} ${model} (${year}, ${color})
}
}
}

const car = new Car('Aston Martin', 'V8 Vantage', '2012', 'Quantum Silver')
console.log(car.toString())



Functional Programming

In the following code, the function inner closes over both fn and args.



function curry(fn) {
const args = []
return function inner(arg) {
if(args.length === fn.length) return fn(...args)
args.push(arg)
return inner
}
}

function add(a, b) {
return a + b
}

const curriedAdd = curry(add)
console.log(curriedAdd(2)(3)()) // 5



Event-Oriented Programming

In the following code, function onClick closes over variable BACKGROUND_COLOR.



const $ = document.querySelector.bind(document)
const BACKGROUND_COLOR = 'rgba(200, 200, 242, 1)'

function onClick() {
$('body').style.background = BACKGROUND_COLOR
}

$('button').addEventListener('click', onClick)
Set background color



Modularization

In the following example, all the implementation details are hidden inside an immediately executed function expression. The functions tick and toString close over the private state and functions they need to complete their work. Closures have enabled us to modularize and encapsulate our code.



let namespace = {};

(function foo(n) {
let numbers = []

function format(n) {
return Math.trunc(n)
}

function tick() {
numbers.push(Math.random() * 100)
}

function toString() {
return numbers.map(format)
}

n.counter = {
tick,
toString
}
}(namespace))

const counter = namespace.counter
counter.tick()
counter.tick()
console.log(counter.toString())`



Examples
Example 1

This example shows that the local variables are not copied in the closure: the closure maintains a reference to the ori

Stack Overflow Q#111102, score: 8350