Function Execution Context and Local Scope

Function Execution Context and Local Scope

Every function call creates a new execution context, and that context defines the function's local scope for that call. Understanding this is key to closures, recursion, and avoiding bugs.

Local Scope Is Per-Call

Each invocation creates a new execution context with its own variable environment. Local variables declared inside the function are not shared between calls.

function add(x, y) {
  var result = x + y;
  return result;
}
add(1, 2); // result = 3 in this call's scope
add(4, 5); // result = 9 in a different call's scope

The two result variables are completely independent.

What Defines Local Scope

• Parameters: become local variables.
• var declarations inside the function: function-scoped.
• let and const declarations inside any block in the function: block-scoped.
• Inner function declarations: stored in full, available throughout the function's local scope.

Outer Scope Reference

Each function execution context has an outer environment reference pointing to its lexical parent. This builds the scope chain. If a variable is not found locally, the engine walks up the chain.

const globalMsg = "hi";
function outer() {
  var outerVar = "there";
  function inner() {
    // local scope: none of its own
    // walks up: outerVar found in outer, globalMsg in global
    console.log(globalMsg, outerVar);
  }
  inner();
}
outer(); // "hi there"

Recursion and Local Scope

Each recursive call has its own local scope. This is why recursion works:

function factorial(n) {
  if (n <= 1) return 1;
  return n * factorial(n - 1);
}
factorial(3);

Three separate scopes, each with its own n (3, 2, 1). Returns unwind, multiplying on the way up.

Closures Persist Local Scope

If a function returns an inner function, the inner function keeps a reference to the outer function's variable environment. The local scope persists even after the outer call returns. That is a closure.

function makeCounter() {
  let count = 0;
  return () => ++count;
}
const c = makeCounter();
c(); // 1
c(); // 2

count persists because the returned arrow keeps the variable environment alive.

The Takeaway

A function's execution context defines its local scope: parameters, var (function-scoped), let/const (block-scoped), and inner functions. Each call has its own locals. The outer environment reference builds the scope chain. Closures keep a local scope alive after the function returns.