JavaScript Tutorial
A closure is created when an inner function keeps access to variables from its lexical parent scope even after parent execution completes.
Why this matters
Closures are used in private state, memoization, module patterns, and many interview questions.
Closures capture references from lexical scope, not copied snapshots in most cases.
Because references are retained, inner functions can read or update outer variables over time.
This behavior enables controlled state without exposing variables globally.
Factory functions for reusable modules with isolated state.
Memoization for caching expensive computations.
Configuration-based function generation for logging, validation, and event handling.
function createCounter(start = 0) {
let count = start;
return function () {
count += 1;
return count;
};
}
const next = createCounter(5);
console.log(next(), next(), next());count stays private and persists due to closure.
function memoizeDouble() {
const cache = {};
return function (n) {
if (cache[n]) return cache[n];
cache[n] = n * 2;
return cache[n];
};
}
const fastDouble = memoizeDouble();
console.log(fastDouble(10), fastDouble(10));cache survives between calls with closure.
function createLogger(moduleName) {
return function log(message) {
console.log("[" + moduleName + "]", message);
};
}
const authLog = createLogger("AUTH");
authLog("Token validated");moduleName stays available for all later logs.
Remember closures retain references to outer scope variables.
Store only required state to avoid memory pressure.
Use let in loops to avoid shared index bugs.
No. Closures are common in real projects for encapsulation and factory patterns.
They can if they retain references to large objects unnecessarily.
Closures hide state via lexical scope, while class fields use instance-based syntax and semantics.
Yes. Async callbacks can access captured outer variables through closure.