What is the Scope Chain in JavaScript?

The scope chain in JavaScript is how the JavaScript engine looks for variables. It determines the order in which scopes are searched when trying to resolve a variable reference.

Understanding Scope First

In JavaScript, scope refers to the current context of code execution. There are two main types:

• Global Scope – variables declared outside any function
• Local Scope – variables declared inside a function

let globalVar = "I’m global";

function outer() {
  let outerVar = "I’m outer";

  function inner() {
    let innerVar = "I’m inner";
    console.log(globalVar); // Accessible
    console.log(outerVar);  // Accessible
    console.log(innerVar);  // Accessible
  }

  inner();
}

outer();

How the Scope Chain Works

When a variable is accessed, JavaScript looks for it in the current scope. If not found, it looks in the outer scope, and continues upward until it reaches the global scope. If it’s not found anywhere, it throws a ReferenceError.

function first() {
  let a = 10;

  function second() {
    let b = 20;

    function third() {
      let c = 30;
      console.log(a, b, c); // 10, 20, 30
    }

    third();
  }

  second();
}

first();

Here, third() can access variables from second() and first() thanks to the scope chain.

Visualizing the Chain

Think of the scope chain as a stack of environments:

• third() → has access to c, b, a
• second() → has access to b, a
• first() → has access to a
• global → has access to global variables only

Why the Scope Chain Matters

• It helps prevent naming conflicts
• Makes functions more predictable
• Important for closures and memory optimization

What Happens When a Variable Isn’t Found?

function check() {
  console.log(notFound); // ReferenceError
}
check();

JavaScript checks the current scope, then moves up the chain. If it doesn’t find the variable, it throws an error.