What Is a Closure in JavaScript?

What Is a Closure in JavaScript?

A closure is a function that remembers the variables from its lexical scope, even after that scope has finished executing. It "closes over" those variables.

The Simplest Example

function outer() {
  const message = "hello";
  function inner() {
    console.log(message);
  }
  return inner;
}
const fn = outer();
fn(); // "hello"
``
`outer` runs, creates `message`, returns `inner`, and its execution context is destroyed. But `fn()` still logs `"hello"`. How? `inner` keeps a reference to `outer`'s lexical environment. That reference is the closure.

### A Function Plus Its Environment

A closure is not just the function. It is the function **plus** the variables it closes over. The function object holds a hidden reference to its outer lexical environment.

### Why Closures Work

JavaScript uses lexical scope. The scope chain is determined by where functions are **written**, not where they are **called**. When `inner` is defined inside `outer`, its outer reference points to `outer`'s environment. That reference travels with the function object.

### A Counter Example

```js
function makeCounter() {
  let count = 0;
  return () => ++count;
}
const counter = makeCounter();
counter(); // 1
counter(); // 2
counter(); // 3
``
Each call to `counter` increments the closed-over `count`. `count` is private: it cannot be accessed directly, only through the returned function.

### Closures Are Everywhere

- **Callbacks**: `setTimeout(() => console.log(x), 0)` closes over `x`.
- **Event handlers**: a handler closes over variables from where it was defined.
- **Higher-order functions**: `map`, `filter`, `reduce` callbacks close over outer variables.
- **Module pattern**: an IIFE returns an object whose methods close over private variables.

### The Takeaway

A closure is a function that remembers its lexical scope. The function object holds a reference to its outer lexical environment, so it can access those variables even after the outer function has returned. Closures power data privacy, callbacks, event handlers, and the module pattern.