Nested Functions and Scope Resolution in JavaScript

Nested Functions and Scope Resolution in JavaScript

When a function is defined inside another function, it forms a nested scope. Variable resolution walks up this nesting via the scope chain.

Lexical (Static) Scope

JavaScript uses lexical scope. The scope chain is determined by where functions are written in the source, not where they are called.

const globalVar = "G";
function outer() {
  const outerVar = "O";
  function inner() {
    const innerVar = "I";
    console.log(innerVar, outerVar, globalVar); // I O G
  }
  inner();
}
outer();

inner's scope chain is inner -> outer -> global, regardless of where inner is called from.

How Resolution Works

When the engine needs a variable:

1. Look in the current variable environment.
2. If not found, follow the outer environment reference to the parent.
3. Repeat until found or the global scope is reached.
4. If still not found, throw ReferenceError.

Closures Arise From This

If an inner function is returned or passed around, it keeps its outer environment reference. That reference is the closure.

function makeAdder(x) {
  return function (y) {
    return x + y;
  };
}
const add5 = makeAdder(5);
add5(3); // 8

The returned function still sees x even after makeAdder returned. The scope chain persists.

Shadowing

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

const name = "Kunal";
function greet() {
  const name = "Asha";
  console.log(name); // "Asha"
}
greet();
console.log(name); // "Kunal"

Inside greet, name resolves to the local one. The outer is hidden.

Dynamic Calls Do Not Change the Chain

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 outer does not change that. This is the key difference between lexical and dynamic scope.

The Takeaway

Nested functions resolve variables through a lexical scope chain built at write time. The chain does not change based on where the function is called. Returning an inner function keeps the chain alive (closure). Local names shadow outer ones.