Closures, scope & hoisting

// A closure is a function that keeps a variable alive after the function that made it has// returned. Read top to bottom; each assert checks the private number at that exact moment.function makeCounter() {  let count = 0;                                             // private: nothing outside can read or change it  return function next() { count += 1; return count; };     // `next` is the closure; it holds on to `count`}const tally = makeCounter();                                 // makeCounter has returned; count is 0 and still aliveconst other = makeCounter();                                 // a second makeCounter() call makes a second private count// If Session 3.2 was today, stop here. Otherwise read sections 1 to 3 next; they are the scope rules, and 3.4// sends you back for them. Sections 4 to 7 are for after Unit 3, and so are 8 and 9.

// Read top to bottom. Each `const seen...` line records what a name holds at that exact moment; the asserts at the// end of each block check the recorded values, so the order of the lines is the lesson.{  const seenBefore = typeof hoisted;                         // 'undefined': checked BEFORE the var line below; var is hoisted as undefined  var hoisted = 1;                                           // the declaration line; now it holds 1  const seenAfter = hoisted;                                 // 1  let tdzBefore;  try { tdzBefore = typeof tdz; } catch (e) { tdzBefore = e.name; }   // 'ReferenceError': checked BEFORE the let line below; let exists but is in the TDZ  let tdz = 2;                                               // the declaration line ends the dead zone  const tdzAfter = tdz;                                      // 2  const k = { a: 1 };  k.a = 2;                                                   // const = the binding is constant, the object is not  const kAfter = k.a;                                        // 2; `k = {}` would be TypeError: Assignment to constant variable}{  if (true) { var leaks = 'var'; let stays = 'let'; }  const afterBlock = [leaks, typeof stays];                  // ['var', 'undefined']: var ignored the block, let did not leak}

const fns1 = [];for (var i = 0; i < 3; i++) fns1.push(() => i);              // one shared `i`; the loop leaves it at 3const fns2 = [];for (let j = 0; j < 3; j++) fns2.push(() => j);              // fresh `j` per iteration// Pre-let fix: IIFE capturing the value:  (function (x) { fns.push(() => x); })(i)

function decl() { return 'declared'; }const expr = () => 'expression';

function makeCounterWithApi(start = 0) {  let n = start;                                             // private — no way in except these functions  return { inc: () => ++n, dec: () => --n, get value() { return n; } };}const c1 = makeCounterWithApi(), c2 = makeCounterWithApi(10);c1.inc(); c1.inc(); c2.dec(); const once = fn => { let done = false, result; return (...a) => (done ? result : (done = true, result = fn(...a))); };let calls = 0;const init = once(() => ++calls);init(); init(); const memoize = fn => {  const cache = new Map();  return (...args) => {    const key = JSON.stringify(args);    if (!cache.has(key)) cache.set(key, fn(...args));    return cache.get(key);  };};let slowCalls = 0;const slowSquare = memoize(x => (slowCalls++, x * x));slowSquare(4); slowSquare(4); slowSquare(5);const fib = memoize(n => (n < 2 ? n : fib(n - 1) + fib(n - 2)));

const curry = fn => function curried(...a) { return a.length >= fn.length ? fn(...a) : (...b) => curried(...a, ...b); };const add3 = curry((a, b, c) => a + b + c);const partial = (fn, ...preset) => (...later) => fn(...preset, ...later);const pipe = (...fns) => x => fns.reduce((v, f) => f(v), x);const compose = (...fns) => x => fns.reduceRight((v, f) => f(v), x);

function debounce(fn, ms, setT = setTimeout, clearT = clearTimeout) {  let t;                                                     // the timer id lives in the closure  return (...a) => { clearT(t); t = setT(() => fn(...a), ms); };}function throttle(fn, ms, now = Date.now) {  let last = -Infinity;                                      // the last accepted time lives in the closure  return (...a) => { if (now() - last >= ms) { last = now(); return fn(...a); } };}{  // Fake timer so the file stays synchronous: `pending` holds the one callback the debounce scheduled.  let debounced = 0, pending = null;  const fakeSet = (cb) => { pending = cb; return 1; }, fakeClear = () => { pending = null; };  const d = debounce(() => debounced++, 100, fakeSet, fakeClear);  d();  d();  pending();                                                 // the timer fires once, 100 ms after the LAST call}{  // Fake clock: `clock` is "now" in ms; the throttle lets one call through per 100 ms.  let throttled = 0, clock = 0;  const th = throttle(() => throttled++, 100, () => clock);  th();  th();  clock = 150;  th();}

const Store = (() => {  const items = [];                                          // private  return { add: x => items.push(x), size: () => items.length };})();Store.add(1);

// After Unit 3, like sections 4 to 7.let shared = 'a';const read = () => shared;shared = 'b';

// After Unit 3, like sections 4 to 7.const x = 'outer';function shadow() { const x = 'inner'; return x; }