In JavaScript, when a function closes over an outer variable, does it capture that variable's value at the moment the function was created, or the variable binding itself? Show the difference with a variable that is reassigned after the function is created.

## What "capture" means here A closure is a function together with the environment in which it was created. The word *capture* misleads people because in some languages a lambda can copy values into itself. JavaScript never does that. When a function object is created, it stores a reference to the *environment record* it was created in — the spec calls this the function's `[[Environment]]` internal slot. When the function later runs, every free identifier in its body (any name not declared inside the function) is resolved by walking that chain of environment records outward until the name is found, and only then is a value read. The consequence follows directly: the read happens at **call time**, not at creation time. Whatever the binding holds at the moment the closure executes is what the closure sees. ## Reassignment after creation is visible ``` let msg = "first"; const show = () => msg; msg = "second"; show(); // "second" ``` Nothing about `show` changed; the binding `msg` changed, and `show` was always pointing at the binding. This also works in the other direction — a closure can be created *before* the variable ever holds a useful value, and will still work once it does, as long as it is called afterwards. That is why a function defined at the top of a module can legitimately read a value assigned lower down at init time. ## Rebinding a whole object is visible too People sometimes accept "primitives are live" but assume the closure holds on to the object it saw: ``` let arr = [1, 2]; const readLen = () => arr.length; arr = [1, 2, 3, 4]; readLen(); // 4, not 2 ``` The closure did not remember the first array. It remembers the name `arr` in a particular environment, and that name now denotes a different array. ## What `const` does and does not do `const` prevents *rebinding* of that particular name, so a closure over a `const` really does always see the same value. It does not deep-freeze anything: if the value is an object, mutating its properties is still fully visible through the closure, because nothing about the binding changed. `const config = {...}` plus `config.level = "debug"` is seen by every closure over `config`. ## Parameters are the built-in way to snapshot Each call to a function creates a fresh environment record with fresh bindings for its parameters, initialised from the argument values. For a primitive argument that is effectively a copy: later reassignment of the *caller's* variable is invisible to the closure, because the closure sees the parameter binding, not the caller's. ``` let n = 1; function hold(x) { return () => x; } const f = hold(n); n = 99; f(); // 1 ``` For an object argument the parameter holds a reference to the same object, so property mutations are still shared — the snapshot is of the reference, not of the object's contents. The same trick works without a helper: declare a local `const copy = value;` inside the enclosing function and close over `copy` instead. That is the honest way to freeze a value at capture time, and it is worth saying out loud in an interview, because it shows you understand that the language gives you liveness by default and a snapshot only on request. ## Why interviewers care Almost every closure bug in real code is a mismatch between the two mental models. Someone builds a handler or a callback expecting it to have "remembered" the value that was in scope when it was created, and instead it reads whatever is there when it fires. Conversely, someone assumes a factory hands out independent state, then discovers all the products read a single shared outer variable. Both are the same fact viewed from opposite sides: closures see bindings, and bindings live in an environment that outlives the call that created it. ## How to answer out loud Say "by binding, not by value", give the two-line reassignment example, then add the two refinements that separate a solid answer from a memorised one: `const` stops rebinding but not mutation, and a parameter (or a local `const` initialised at capture time) is how you deliberately take a snapshot.