Output Questions: Hoisting & Scope

undefined
5

var declarations are hoisted to the top of their function/global scope but their value is not. The engine treats it as:

var a;          // hoisted — exists but is undefined
console.log(a); // undefined
a = 5;
console.log(a); // 5

ReferenceError: Cannot access 'x' before initialization

let and const are hoisted but placed in the Temporal Dead Zone — they exist but are inaccessible until the declaration line is evaluated. Accessing them before that line throws a ReferenceError.

"foo"
undefined

• Function declarations are fully hoisted — both the name and the body. You can call foo() before its definition.
• Function expressions (var bar = function…) hoist only the var bar — the variable is undefined until that line runs. Calling bar() before line 5 throws TypeError: bar is not a function.

1
"undefined"

var ignores block scope — x leaks out of the block into the surrounding function/global scope. let is block-scoped, so y doesn’t exist outside the {}. typeof on an undeclared variable returns "undefined" (not a ReferenceError — a special case).

"function"
"string"

When a variable and a function declaration share the same name, the function declaration wins during hoisting — it takes precedence over var. So before any code runs, foo is the function. After foo = 'variable' runs on line 2, foo becomes the string.

"undefined"   (outer, before block)
"function"    (inside block, after hoisting within block)
"function"    (inside block, after declaration)
"function"    (outer, after block — hoisted out in non-strict mode)

In non-strict mode, function declarations inside blocks have complex legacy behavior: the declaration is hoisted to the top of the block, but the name is also created in the outer scope (as undefined initially), and when execution passes the declaration line, the outer binding is updated. This is an engine-specific quirk — in strict mode, block-scoped functions stay in the block. Avoid block-level function declarations.

3
3
3

var is function-scoped — there is one shared i across all iterations. By the time the setTimeout callbacks fire (after the loop completes), i is 3. All three closures close over the same binding.

0
1
2

let is block-scoped and creates a fresh binding per iteration. Each callback closes over its own independent j.

2
2

Both var a declarations are in the same function/global scope — var allows re-declaration and they both refer to the same variable. The inner block updates the shared a to 2, so both logs print 2.

2
1

const is block-scoped — the inner const x = 2 is a completely separate binding from the outer const x = 1. No error; each block has its own x.

"local"
"global"

The parameter x shadows the outer x within the function body. The global x is untouched.

ReferenceError: Cannot access 'MyClass' before initialization

class declarations are hoisted but placed in the TDZ, just like let/const. You cannot use a class before its declaration. (The second console.log never runs.)