JavaScript Hoisting — Async Loop Bug Leaked User Data

// var: function-scoped — ignores block boundaries
function testVar() {
  if (true) {
    var x = 10;  // declared inside if block
  }
  console.log(x); // 10 — accessible outside the block!
}
testVar();

// let: block-scoped — respects {} boundaries
function testLet() {
  if (true) {
    let y = 10;
  }
  // console.log(y); // ReferenceError — y not accessible here
}

// const: block-scoped + cannot be reassigned
const MAX = 100;
// MAX = 200; // TypeError: Assignment to constant variable

// const with objects — the binding is const, not the object
const user = { name: 'Alice' };
user.name = 'Bob';  // fine — mutating the object, not the binding
console.log(user.name); // Bob

// Function declaration — fully hoisted, works before definition
console.log(greet('Forge'));  // 'Hello, Forge!' — works!

function greet(name) {
  return `Hello, ${name}!`;
}

// var — hoisted but undefined
console.log(city);  // undefined — hoisted, not initialised
var city = 'London';
console.log(city);  // 'London'

// let/const — temporal dead zone (TDZ)
// console.log(country);  // ReferenceError: Cannot access before initialization
let country = 'UK';
console.log(country);  // 'UK'

// Function expression — NOT hoisted (it is a variable assignment)
// console.log(sayHi());  // TypeError: sayHi is not a function
const sayHi = function() { return 'Hi!'; };
console.log(sayHi());  // 'Hi!'

// TDZ example with let
{
  // TDZ starts here for `a`
  // console.log(a); // ReferenceError: Cannot access 'a' before initialization
  let a = 10; // TDZ ends here
  console.log(a); // 10
}

// TDZ is also scope-specific
function test() {
  if (true) {
    // TDZ for `x` starts
    // console.log(x); // ReferenceError
    let x = 5;
    console.log(x); // 5
  }
  // TDZ for `x` ended when the block closed, but `x` is no longer accessible
}

// typeof in TDZ also throws
{
  // console.log(typeof y); // ReferenceError in TDZ for let
  let y = 1;
}

// const has the same TDZ behaviour
{
  // const z = z + 1; // ReferenceError — z is in TDZ
  const z = 1;
}

const globalVar = 'global';

function outer() {
  const outerVar = 'outer';

  function inner() {
    const innerVar = 'inner';
    // Can access all three — lexical scope chain
    console.log(innerVar);   // 'inner'
    console.log(outerVar);   // 'outer'
    console.log(globalVar);  // 'global'
  }

  inner();
  // console.log(innerVar); // ReferenceError — inner scope not accessible here
}

outer();

// Scope chain: inner → outer → global → undefined
// JS looks up the chain until it finds the variable or exhausts the chain

// Function declaration — fully hoisted
console.log(sum(2, 3)); // 5 — works!

function sum(a, b) {
  return a + b;
}

// Function expression assigned to var — variable hoisted, function not
console.log(multiply); // undefined (var hoisted)
// console.log(multiply(2, 3)); // TypeError: multiply is not a function
var multiply = function(a, b) {
  return a * b;
};
console.log(multiply(2, 3)); // 6 — now it works

// Function expression assigned to let — not accessible before declaration
// console.log(divide(6, 2)); // ReferenceError: Cannot access 'divide' before initialization
const divide = function(a, b) {
  return a / b;
};
console.log(divide(6, 2)); // 3

// Arrow functions are also function expressions
// console.log(subtract(5, 2)); // ReferenceError
const subtract = (a, b) => a - b;
console.log(subtract(5, 2)); // 3