ক্লোজার এবং স্কোপ (Closures & Scope)

// Global scope
let globalVar = "I'm global!";

function showScope() {
  // Function scope
  let functionVar = "I'm in a function!";
  console.log(globalVar);   // ✅ can see global
  console.log(functionVar); // ✅ can see own variable

  if (true) {
    // Block scope
    let blockVar = "I'm in a block!";
    const alsoBlock = "Me too!";
    var notBlock = "I ignore blocks! (var is function-scoped)";
    console.log(blockVar);   // ✅
    console.log(functionVar); // ✅ can see outer function scope
  }

  // console.log(blockVar);  // ❌ ReferenceError — block scope!
  console.log(notBlock);     // ✅ var escapes the block!
}

showScope();
// console.log(functionVar);   // ❌ ReferenceError — function scope!

I'm global!
I'm in a function!
I'm in a block!
I'm in a function!
I ignore blocks! (var is function-scoped)

// Function declarations are fully hoisted
console.log(greet("World")); // "Hello, World!" — works!
function greet(name) {
  return `Hello, ${name}!`;
}

// var is hoisted but initialized to undefined
console.log(x); // undefined (not an error!)
var x = 10;
console.log(x); // 10

// let/const are hoisted but in the "temporal dead zone"
// console.log(y); // ❌ ReferenceError: Cannot access 'y' before initialization
let y = 20;
console.log(y); // 20

// Arrow functions follow their variable rules
// console.log(double(5)); // ❌ ReferenceError (const is in TDZ)
const double = (n) => n * 2;
console.log(double(5)); // 10

Hello, World!
undefined
10
20
10

// Basic closure — inner function remembers outer variables
function createCounter() {
  let count = 0; // this variable is "enclosed"
  return {
    increment() { count++; return count; },
    decrement() { count--; return count; },
    getCount()  { return count; }
  };
}

const counter = createCounter();
console.log(counter.increment()); // 1
console.log(counter.increment()); // 2
console.log(counter.increment()); // 3
console.log(counter.decrement()); // 2
// count is private! We can't access it directly:
// console.log(count); // ❌ ReferenceError

// Each call creates a NEW closure with its own variables
const counter2 = createCounter();
console.log(counter2.getCount());  // 0 (independent!)
console.log(counter.getCount());   // 2 (still has its own count)

// Practical use: function factory
function createGreeter(greeting) {
  return (name) => `${greeting}, ${name}!`;
}

const sayHello = createGreeter("Hello");
const sayHola = createGreeter("Hola");
console.log(sayHello("Kaisar"));  // "Hello, Kaisar!"
console.log(sayHola("Kaisar"));   // "Hola, Kaisar!"

1
2
3
2
0
2
Hello, Kaisar!
Hola, Kaisar!

// The classic closure-in-loop bug with var
for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log("var:", i), 100);
}
// Prints: 3, 3, 3 — because var is shared, and i is 3 when callbacks run

// Fixed with let — each iteration gets its own i
for (let j = 0; j < 3; j++) {
  setTimeout(() => console.log("let:", j), 200);
}
// Prints: 0, 1, 2 — each callback closes over its own j

// IIFE — Immediately Invoked Function Expression
// Creates a private scope
const gameModule = (() => {
  let score = 0;           // private!
  let highScore = 0;       // private!

  return {
    addPoints(pts) {
      score += pts;
      if (score > highScore) highScore = score;
      return score;
    },
    reset() {
      score = 0;
    },
    getHighScore() {
      return highScore;
    }
  };
})(); // <-- () immediately invokes it

console.log(gameModule.addPoints(100));  // 100
console.log(gameModule.addPoints(50));   // 150
gameModule.reset();
console.log(gameModule.getHighScore());  // 150
// console.log(score); // ❌ ReferenceError — score is private!

var: 3
var: 3
var: 3
let: 0
let: 1
let: 2
100
150
150