The Scope Chain in JavaScript: How Variable Resolution Works

The Scope Chain in JavaScript: How Variable Resolution Works

The scope chain is the linked list of lexical environments that the engine walks to resolve a variable. It is built at function definition time, not call time.

How Resolution Works

When the engine needs a variable:

1. Look in the current lexical environment's environment record.
2. If not found, follow the outer reference to the parent environment.
3. Repeat until found or the global environment is reached.
4. If not found anywhere, throw ReferenceError.

Example

const globalVar = "G";
function outer() {
  const outerVar = "O";
  function inner() {
    const innerVar = "I";
    console.log(innerVar, outerVar, globalVar); // I O G
  }
  inner();
}
outer();
``
When `inner` runs and looks up `outerVar`:

- `inner`'s environment record: has `innerVar`, not `outerVar`.
- Follow outer reference to `outer`'s environment: has `outerVar`. Found.

If it needed `globalVar`:

- `inner` -> `outer` -> `global`. Found at the top.

### The Chain Is Lexical

The chain is determined by where functions are **written**, not where they are **called**:

```js
function inner() { console.log(x); }
function outer() {
  const x = 10;
  inner();
}
const x = 99;
outer(); // 99, not 10
``
`inner` was written in the global scope, so its chain is `inner -> global`. Calling it from inside `outer` does not change that.

### The Chain and Closures

If a function is returned, it keeps its outer references. The chain persists:

```js
function makeAdder(x) {
  return function (y) {
    return x + y; // x is found via the chain, even after makeAdder returns
  };
}
const add5 = makeAdder(5);
add5(3); // 8
``
### Shadowing

A local variable with the same name as an outer one shadows the outer:

```js
const name = "Kunal";
function greet() {
  const name = "Asha";
  console.log(name); // "Asha" (local shadows global)
}
``
The engine finds the local first and stops; it never reaches the global.

### The Takeaway

The scope chain is the linked list of lexical environments the engine walks to resolve variables. It is built lexically (at write time). The engine looks locally first, then follows outer references up to the global scope. Shadowing stops the search early. Closures work because the chain persists after the outer function returns.