In JavaScript, a closure is a combination of a function and the lexical environment within which that function was declared. It allows a function to access and remember variables from its outer (enclosing) scope even when the function is executed outside that scope. To understand closures, it's important to grasp the concept of lexical scope. Lexical scope means that variables and functions are defined within their containing scope, and they have access to variables from their parent scopes. When a function is defined inside another function, the inner function has access to variables and parameters of the outer function. Here's an example to demonstrate closures in JavaScript: 

function outer() {
  var outerVariable = 'I am from outer';

  function inner() {
    console.log(outerVariable);
  }

  return inner;
}

var closure = outer();
closure(); // Output: I am from outer
In this example, the `outer` function defines a variable called `outerVariable` and a nested function called `inner`. The `inner` function has access to the `outerVariable` even after the `outer` function has finished executing. When we invoke `outer()` and assign the returned `inner` function to the variable `closure`, we create a closure. The closure variable still holds a reference to the `inner` function along with its surrounding lexical environment, which includes the `outerVariable`. When we call `closure()`, it logs the value of `outerVariable`. Closures are powerful because they enable functions to "remember" the variables in their lexical scope, even if the outer function has completed execution or the variables are not accessible in the current scope. This behavior allows for data encapsulation, private variables, and the creation of functions that can hold onto state information. Closures are commonly used in scenarios like creating private variables, implementing function factories, and working with asynchronous code where you want to maintain access to variables across asynchronous callbacks. It's important to note that closures can also lead to memory leaks if not handled carefully, as they keep references to the variables in their outer scopes, preventing them from being garbage collected. It's a good practice to be mindful of closure usage and avoid unnecessary memory consumption.