Closures at work: private state, once, memoize, debounce, curry

Lesson 2 showed what a closure is. This lesson is about using one: each pattern below is a function that returns another function, and the returned function keeps private variables alive between calls.

Private state

function createWallet() {
  let balance = 0;                    // nobody outside can touch this
  return {
    deposit(n) { balance += n; return balance; },
    balance: () => balance,
  };
}

There is no property called balance to overwrite: the only way to change it is through deposit. Every call to createWallet creates a fresh balance, so two wallets never share one.

Wrappers that count calls: once and limit

A wrapper can keep its own private state about the function it wraps. once(fn) is the best-known case: the first call runs fn and keeps the result, and every later call returns that kept result without running fn again — useful for initialisation that must not run twice. Record "has it run?" in its own flag, because the first result itself may be undefined, 0 or "".

The example below uses the same idea for a different rule: limit(fn, max) lets fn run max times and then refuses, with a counter that only the wrapper can see.

1function limit(fn, max) {2  let calls = 0;3  return (...args) => {4    if (calls >= max) throw new Error(`limit of ${max} reached`);5    calls++;6    return fn(...args);7  };8}9 10function createWallet() {11  let balance = 0;12  return {13    deposit(n) {14      balance += n;15      return balance;16    },17    balance: () => balance,18  };19}20 21export function run() {22  const sendCode = limit((phone) => `code sent to ${phone}`, 2);23  const sends = ["555-01", "555-02", "555-03"].map((phone) => {24    try {25      return sendCode(phone);26    } catch (e) {27      return e.message;28    }29  });30 31  const a = createWallet();32  const b = createWallet();33  a.deposit(10);34  a.deposit(5);35  b.deposit(1);36 37  return { sends, a: a.balance(), b: b.balance(), field: a.balance === 15 };38}

memoize

memoize(fn) caches results by argument, so a repeated call skips the work. The function must be pure — same arguments, same result, no side effects — or the cache returns stale answers. Two details decide whether a memoize is correct:

• The cache key must identify the arguments exactly. Joining them into a string with no separator makes (1, 12) and (11, 2) both "112". JSON.stringify(args) gives "[1,12]" and "[11,2]".
• Check whether the key is present, not whether the value is truthy. if (cache[key]) recomputes every result that is 0, "" or false. A Map with has avoids both that and the inherited-key problems of a plain object (lesson 15).

An unbounded cache also grows forever; real ones cap their size or expire entries. Both key problems, checked:

1export function run() {2  const cache = {};3  cache[[1, 12].join("")] = 13;          // key "112"4  const joinedCollide = [11, 2].join("") in cache;5 6  const jsonA = JSON.stringify([1, 12]);7  const jsonB = JSON.stringify([11, 2]);8 9  const results = new Map([["0,0", 0]]);10  const truthyCheckSaysCached = Boolean(results.get("0,0"));11  const hasSaysCached = results.has("0,0");12 13  return { joinedCollide, jsonA, jsonB, truthyCheckSaysCached, hasSaysCached };14}

debounce

debounce(fn, ms) delays fn until calls have stopped for ms milliseconds; each new call cancels the pending timer and starts a new one. A burst of keystrokes in a search box becomes one request with the final text. (Throttle is the sibling: at most one call per interval, spread through the burst.)

function debounce(fn, ms) {
  let timer;
  return (...args) => {
    clearTimeout(timer);
    timer = setTimeout(() => fn(...args), ms);
  };
}

1function debounce(fn, ms) {2  let timer;3  return (...args) => {4    clearTimeout(timer);5    timer = setTimeout(() => fn(...args), ms);6  };7}8 9const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));10 11export async function run() {12  const searches = [];13  const search = debounce((text) => searches.push(text), 30);14 15  for (const text of ["j", "ja", "jav", "java", "javas"]) search(text);16  await wait(100);17  search("python");18  await wait(100);19 20  return searches;21}

curry

curry(fn) turns f(a, b, c) into a function that also accepts its arguments in instalments: f(a)(b)(c), f(a, b)(c). It is a closure over "the arguments collected so far" that compares their count with fn.length, the number of declared parameters. The trap is storing the collected arguments in one shared array: a partial application such as const double = curriedMultiply(2) must be reusable, so each call has to build a new list instead of pushing onto the old one. That is the exercise.

Common mistakes

• A cache key built by concatenation. `${a}${b}` collides for (1, 12) and (11, 2) and returns the wrong cached answer.
• if (cache[key]) instead of cache.has(key). Falsy results are recomputed every time, so the memoised function is not memoised for them.
• Keeping state at module level instead of inside the factory. Every counter or cache created then shares one variable.
• Debounce that does not clear the previous timer. Every call in the burst still fires, just later.

What interviewers ask

• Implement memoize. What are its limits? — A keyed by serialised arguments, checked with ; only safe for pure functions, grows without bound, and object arguments need a stable key.