Scope & the Lexical Environment

The plain-language idea

Scope answers one question: from here, which variables can I see?

Think of scope like rooms in a house. Code inside a room can see everything in its own room and in the rooms it's nested inside — but not what's tucked away inside sibling rooms.

The word lexical just means "decided by where the code is written." JavaScript works out scope by reading the source, before anything runs — not by who calls what at runtime.

See it in a real thing

Every time you write a function, you open a new room:

const appName = "Praxis";        // outer room

function greet() {
  const user = "Adesh";          // inner room
  return `Hi ${user}, welcome to ${appName}`; // can see both
}

// console.log(user); // ReferenceError — the outer room can't see inside

greet can reach outward to appName, but the outside can't reach inward to user. That one-way visibility is the whole game.

Two rooms: the outer one (the file) holds appName. The inner one (greet) holds user.

BackNext

What people usually miss

Watch out

• var ignores block scope. A var declared inside an if leaks to the whole function. let and const respect the surrounding block.
• The temporal dead zone. A let or const variable exists from the top of its block, but you can't touch it until the line that declares it — accessing it early throws, it isn't undefined.
• Scope is lexical, not dynamic. It's set by where the function is written, not where it's called. Move the function, and its outer scope moves with it.

Why this matters in interviews

If you can explain lexical vs dynamic scope and why the temporal dead zone exists, you've already signalled more depth than most candidates. The natural follow-up is closures — which is exactly where we go next.