Question 1

What are global, function, and block scope in JavaScript?

Accepted Answer

Global is top-level; function scope wraps var/params; block scope ({}) applies to let, const, and class bindings. Global scope is the outermost environment — browsers expose it via window/globalThis for classic scripts. Function scope means var declarations and function declarations inside a function are visible throughout that function, ignoring inner blocks. Block scope, introduced widely with ES6, means let, const, and class declarations are confined to the nearest enclosing {} (including if, for, while, and bare blocks). Modules have their own top-level scope that does not leak to globalThis. Choosing the right declaration keyword is the practical way to control scope.

Question 2

How does the scope chain work when resolving a variable?

Accepted Answer

The engine looks in the current lexical environment, then walks outer environments until it finds the binding or throws ReferenceError. Identifier resolution follows the lexical scope chain (static scope): nested functions close over the environment where they were defined, not where they are called. Lookup starts in the active Lexical Environment, then follows the [[OuterEnv]] link to parent environments, eventually reaching the global environment. If the binding is never found, you get a ReferenceError. Shadowing occurs when an inner binding hides an outer one with the same name. This chain is fixed at definition time for lexical bindings — which is the foundation of closures.

Question 3

Compare var, let, and const in terms of scope, redeclaration, and reassignment.

Accepted Answer

var is function-scoped and redeclarable; let/const are block-scoped; only const forbids reassignment of the binding. var: function/global scoped, hoisted as undefined, can be redeclared in the same scope, assignable anytime. let: block-scoped, TDZ until initialized, cannot redeclare in the same scope, can reassign. const: like let but the binding cannot be reassigned after initialization — objects/arrays held by const can still be mutated unless frozen. Prefer const by default, let when reassignment is needed, and avoid var in new code except for rare legacy interop.

Question 4

What is the Temporal Dead Zone (TDZ), and how does it show up in interviews?

Accepted Answer

TDZ is the period from entering a scope until a let/const/class binding is initialized; accessing it throws ReferenceError. When a block is entered, let/const bindings exist in the environment but are uninitialized. Any read or write before the declaration statement runs throws ReferenceError — that window is the TDZ. It also affects default parameters that reference later parameters, and typeof on an undeclared let (unlike undeclared globals, typeof does not safely return 'undefined' for TDZ bindings). TDZ exists to catch use-before-define bugs that var's silent undefined hid.

Question 5

How does module scope differ from classic script global scope?

Accepted Answer

ES modules have their own top-level scope; top-level bindings do not become properties of globalThis, and modules are strict by default. A classic <script> (non-module) shares the global object: top-level var and function declarations become globalThis properties. An ES module has a Module Environment Record: top-level let/const/class/function/var stay module-private unless exported. Modules always run in strict mode, support import/export, and are deferred by default when loaded via type="module". This isolation reduces global namespace collisions and makes dependencies explicit. Cross-module sharing happens only through exports or intentional globalThis assignment.

Question 6

Explain illegal shadowing and how catch clause bindings interact with block scope.

Accepted Answer

You cannot shadow a let/const with var in nested blocks of the same function in ways the spec forbids; catch bindings are block-scoped to the catch block. Shadowing is normally allowed (let x inside a block can hide outer let x). Illegal shadowing occurs in specific cases — notably declaring a var that would hoist across a block containing a let/const of the same name, or conflicts between function-scoped and block-scoped names that the early error rules catch at parse time. A catch (err) parameter is scoped only to that catch block (like let). Optional catch binding (catch {) avoids an unused binding. In nested try/catch, each err is independent. These rules matter when transpiling or when debugging surprising SyntaxErrors about redeclaration.

Scope JavaScript Interview Questions

Other JavaScript interview topics