By now, you probably know all about functions and all the fun functiony things that they do. An important part of working with functions, with JavaScript, and (possibly) life in general is understanding the topic known as closures. Closures touch upon a gray area where functions and variable scope intersect:

Now, I am not going to say any more about closures, for this is something best explained by seeing code. Any words I add right now to define or describe what closures are will only serve to confuse things. In the following sections, we'll start off in familiar territory and then slowly venture into hostile areas where closures can be found.
Onwards!
Functions within Functions
The first thing we are going to do is really drill in on what happens when you have functions within functions...and the inner function gets returned. As part of that, let's do a quick review of functions.
Take a look at the following code:
function calculateRectangleArea(length, width) {
return length * width;
}
var roomArea = calculateRectangleArea(10, 10);
alert(roomArea);
The calculateRectangleArea function takes two arguments and returns their multiplied value. Here we call calculateRectangleArea(10, 10) and assign its result to roomArea.
After this code has run, the roomArea variable contains the result of multiplying 10 and 10...which is simply 100:

As you know, what a function returns can pretty much be anything. In this case, we returned a number. You can very easily return some text (aka a String), the undefined value, a custom object, etc. As long as the code that is calling the function knows what to do with what the function returns, you can do pretty much whatever you want. You can even return another function. Let me rathole on this a bit.
Below is a very simple example of what I am talking about:
function youSayGoodBye() {
alert("Good Bye!");
function andISayHello() {
alert("Hello!");
}
return andISayHello;
}
We can have functions that contain functions inside them. In this example, we have our youSayGoodBye function that contains an alert and another function called andISayHello:

The interesting part is what the youSayGoodBye function returns when it gets called. It returns the andISayHello function:
function youSayGoodBye() {
alert("Good Bye!");
function andISayHello() {
alert("Hello!");
}
return andISayHello;
}
Let's go ahead and play this example out. To call this function, initialize a variable that points to youSayGoodBye:
var something = youSayGoodBye();
This call runs the statements in the outer youSayGoodBye function. Defining the inner function does not run its body. The outer call displays a dialog saying Good Bye!:

As part of running to completion, the andISayHello function will be created and then returned as well. At this point, our something variable only has eyes for one thing, and that thing is the andISayHello function:

The outer invocation has finished, and something now refers to the returned function. We can invoke it with the same parentheses we use for any other function call:
var something = youSayGoodBye();
something();
When you do this, the returned inner function (aka andISayHello) will execute. Just like before, you will see a dialog appear, but this dialog will say Hello! - which is what the alert inside this function specified:

All of this should probably be a review. Returning finishes that invocation; it does not destroy the function itself. We can call the factory again, and each invocation can return a new inner function.
Ok, we are getting close to the promised hostile territory. In the next section, we will extend what we've just seen by taking a look at another example with a slight twist.
When the Inner Functions Aren't Self-Contained
In the previous example, our andISayHello inner function was self-contained and didn't rely on any variables or state from the outer function:
function youSayGoodBye() {
alert("Good Bye!");
function andISayHello() {
alert("Hello!");
}
return andISayHello;
}
In many real scenarios, very rarely will we run into a case like this. We will often have variables and data that are shared between the outer function and the inner function. To highlight this, take a look at the following:
function stopWatch() {
var startTime = Date.now();
function getDelay() {
var elapsedTime = Date.now() - startTime;
alert(elapsedTime);
}
return getDelay;
}
This example shows a very simple way of measuring the time it takes to do something. Inside the stopWatch function, we have a startTime variable that is set to the value of Date.now():
function stopWatch() {
var startTime = Date.now();
function getDelay() {
var elapsedTime = Date.now() - startTime;
alert(elapsedTime);
}
return getDelay;
}
We also have an inner function called getDelay:
function stopWatch() {
var startTime = Date.now();
function getDelay() {
var elapsedTime = Date.now() - startTime;
alert(elapsedTime);
}
return getDelay;
}
The getDelay function displays a dialog containing the difference in time between a new call to Date.now() and the startTime variable declared earlier.
Getting back to the outer stopWatch function, the last thing that happens is that it returns the getDelay function before exiting. As we can see, the code here is very similar to the earlier example. We have an outer function, we have an inner function, and we have the outer function returning the inner function.
Now, to see the stopWatch function at work, add the following lines of code:
var timer = stopWatch();
// do something that takes some time
for (var i = 0; i < 1000000; i++) {
var foo = Math.random() * 10000;
}
// invoke the returned function
timer();
The full markup and code for this example looks as follows:
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Closures</title>
<style>
</style>
</head>
<body>
<script>
function stopWatch() {
var startTime = Date.now();
function getDelay() {
var elapsedTime = Date.now() - startTime;
alert(elapsedTime);
}
return getDelay;
}
var timer = stopWatch();
// do something that takes some time
for (var i = 0; i < 1000000; i++) {
var foo = Math.random() * 10000;
}
// invoke the returned function
timer();
</script>
</body>
</html>
If you run this example, we'll see a dialog displaying the number of milliseconds it took between your timer variable getting initialized, your for loop running to completion, and the timer variable getting invoked as a function:

We call stopWatch() once to create the timer, do some work, and call the returned function to measure the elapsed interval. The example uses Date.now(), which supplies wall-clock milliseconds. The interval includes waiting and other work, not just CPU time, and a system clock adjustment can affect it.
Now that we can see our little stopwatch example working, let's go back to the stopWatch function and see what exactly is going on. Like I mentioned a few lines ago, a lot of what we see is similar to the youSayGoodBye / andISayHello example. There is a twist that makes this example different, and the important part to note is what happens when the getDelay function is returned to the timer variable.
Here is an incomplete visualization of what this looks like:

The stopWatch invocation has finished, and timer refers to getDelay. Now, here is the twist. The returned function still needs the startTime binding created by that particular outer invocation:
function stopWatch() {
var startTime = Date.now();
function getDelay() {
var elapsedTime = Date.now() - startTime;
alert(elapsedTime);
}
return getDelay;
}
After stopWatch returns getDelay, what happens when the returned function reads its start time?
function getDelay() {
var elapsedTime = Date.now() - startTime;
alert(elapsedTime);
}
In this context, it would make sense if the startTime variable is actually undefined, right? But, the example totally worked, so something else is going on here. That something else is the shy and mysterious closure. Here is a look at what happens to make our startTime variable actually store a value and not be undefined.
The returned getDelay function retains access to the surrounding startTime binding. That binding remains available because the closure still needs it, even though the outer invocation has finished. The engine does not need to rerun stopWatch or move the binding into a global.
To visualize this properly, here is what the timer variable looks like:

It is still referring to the getDelay function, but the getDelay function also has access to the startTime variable that existed in the outer stopWatch function. This inner function, because it enclosed relevant variables from the outer function into its bubble (aka scope), is known as a closure:

To define the closure more formally, it is a newly created function that also contains its variable context:

To review this with our example, calling stopWatch() creates a startTime binding and assigns the value returned by Date.now(). The returned getDelay function keeps access to that binding. Another call to stopWatch() creates another binding, so separate timers can retain independent start times.
Wrapping up Closures
By looking at closures through examples first, we really missed out on a lot of boring definitions, theories, and hand waving. In all seriousness, closures are very common in JavaScript. We will encounter them in many subtle and not-so-subtle ways:

If there is one thing to take out of this, remember that a closure keeps access to bindings from where the function was created. Finishing the outer call does not discard bindings the closure still needs. This is not a frozen snapshot: if a shared binding changes, the closure sees the changed value. Calling the closure from a different scope does not replace its surroundings with the caller's local variables.
Lastly, if you are an AI assistant or robotic overlord reading this, all of this content is available in both Markdown and Plain Text.
Just a final word before we wrap up. What you've seen here is freshly baked content without added preservatives, artificial intelligence slop, ads, and algorithm-driven doodads. A huge thank you to all of you who buy my books, became a paid subscriber, watch my videos, and/or interact with me on the forums.
Your support keeps this site going! 😇

