Closures

A closure is a programming construct in which a function is bundled with its surrounding lexical environment. It allows the function to access variables from its defining scope even after that scope has exited, enabling data persistence and stateful behavior through functions.

Closures arise in languages with lexical scoping when a function is defined inside another function and references variables from the outer function. If the inner function is returned or passed elsewhere, it retains access to those captured bindings, forming a closure.

The captured environment is typically represented as an internal object that holds bindings to the outer variables. The environment remains alive as long as any closure referencing it is reachable, effectively extending the lifetimes of those variables beyond their original scope.

Example in JavaScript:

function makeCounter() {

let count = 0;

return function() { count += 1; return count; };

}

const c = makeCounter();

c(); // 1

c(); // 2

This pattern is used for factory functions, data encapsulation, memoization, and function factories. Many languages implement closures with varying semantics of variable capture, mutability, and performance.

In some languages, closures capture by value; others capture by reference or with move semantics. In JavaScript, closures also interact with the this value and may require bindings or arrow functions. Closure-aware patterns can improve modularity but require care to avoid excessive memory use or hard-to-debug behavior.

See also: lexical scope, first-class function, higher-order function, memoization, module pattern.