Closures
A closure is a function that retains access to variables from the scope in which it was defined, even after that outer scope has finished executing.
Definition
A closure is a function that retains access to variables from the scope in which it was defined, even after that outer scope has finished executing.
Overview
Closures are a fundamental concept in languages that treat functions as first-class values, including JavaScript, Python, and many functional languages. When a function is defined inside another function, it 'closes over' the variables of its enclosing scope, meaning it keeps a live reference to them rather than a snapshot. This is what allows an inner function returned from an outer function to still read and even modify variables that were local to the outer function, long after that outer function has returned. Closures are the mechanism behind many everyday patterns: callback functions that need access to state from where they were created, event handlers that remember the context they were attached in, and factory functions that generate specialized functions with pre-configured behavior. They're also central to implementing private state in JavaScript before native class private fields existed — a function can expose a public interface while keeping internal variables inaccessible from outside, which is a lightweight form of encapsulation. Closures are tightly connected to higher-order functions — functions that take or return other functions — since returning a closure from a factory function is one of the most common uses of higher-order functions in practice. They also interact with asynchronous programming: a callback passed to a timer or an event listener is a closure, capturing whatever variables it needs at the moment it's eventually invoked. A classic pitfall involves closures inside loops: because closures capture variables (not values) by reference in many languages, a closure created inside a loop using a variable declared with `var` in JavaScript can end up referencing the loop variable's final value rather than the value at the time the closure was created — a mistake that block-scoped declarations like `let` were designed to prevent.
Key Concepts
- Inner functions retain access to variables from their enclosing scope
- Variables are captured by reference, not by value, in most languages
- Enables private state and lightweight encapsulation without classes
- Core mechanism behind factory functions and function currying
- Essential to how callbacks and event handlers retain context
- Common source of bugs when used carelessly inside loops
- Foundational concept in functional programming and JavaScript
Use Cases
Frequently Asked Questions
From the Blog
JavaScript Closures Explained With Examples
Learn what JavaScript closures are, how they capture variables from an outer scope, and see practical examples covering counters, data privacy, and common pitfalls.
Read More ProgrammingUnderstanding Closures in JavaScript
A JavaScript closure is a function that remembers variables from the scope where it was created, letting you build private state, factories, and stable callbacks.
Read More ProgrammingPython scope explained: LEGB, closures, global and nonlocal
Make scoping errors predictable. Python decides a name is local at compile time if the function assigns to it anywhere, which explains UnboundLocalError, and closures capture the variable rather than its value, which explains the loop-in-a-lambda surprise.
Read More