A closure is formed when an inner function preserves access to the lexical scope of its outer function, even after the outer function has finished executing. This allows the returned function to reference variables from the context in which it was created.

const createAccumulator = (start) => {
  let current = start;
  return (incrementBy) => {
    current += incrementBy;
    return current;
  };
};

const adder = createAccumulator(5);
console.log(adder(10)); // 15
console.log(adder(5));  // 20

In this example, createAccumulator initializes a local variable current. It returns a new function that modifies current based on an argument. Normally, local variables vanish when a function exits. However, because the returned function references current, the variable remains in memory. Subsequent calls to adder update this persisted value rather than resetting it.

The primary advantages of closures include:

• Data encapsulation, allowing variables to be hidden from the global scope.
• State retention, enabling functions to "remember" previous invocations.

This pattern is frequently used in modern JavaScript. Common scenarios include:

• Asynchronous callbacks, such as those used in Promises or network requests.
• DOM event listeners that need to access specific data.
• Functions scheduled with setTimeout or setInterval.
• Module patterns that simulate private methods.

Developers should be cautious about memory usage. Since closures keep their containing scope alive, they consume memory that would otherwise be garbage collected. Creating excessive closures, especially within loops or long-running processes, can lead to performance degradation or memory leaks. To prevent leaks, ensure that references held by closures are explicitly set to null when they are no longer required.

A memory leak is defined as a failure to release memory that is no longer being utilized by the application. Over time, this unclaimed memory accumulation degrades system performance and may eventually force the application to terminate.