Замыкания на практике: счётчики и приватность

Обычная переменная внутри функции живёт ровно до конца вызова. Но если функция вернёт другую функцию, которая эту переменную читает, — переменная останется жить, а снаружи к ней не будет ни одного пути. Это и есть приватность: не соглашение «не трогайте», а физическая невозможность.

function makeCounter() {
  let count = 0;
  return {
    up: () => ++count,
    value: () => count
  };
}
const c = makeCounter();
c.up(); c.up();
console.log(c.value(), c.count);

Обратите внимание на c.count: свойства с таким именем у объекта просто нет. Мы не прятали его подчёркиванием и не писали #private — переменная осталась в области видимости, которую объект не показывает.

Каждый вызов фабрики создаёт новое замыкание со своей переменной. Счётчики не мешают друг другу — это ключевое свойство, из-за которого приём вообще работает.

function makeCounter() {
  let count = 0;
  return () => ++count;
}
const a = makeCounter();
const b = makeCounter();
a(); a(); a();
console.log(a(), b());

Фабрика — та же идея, только запомненная переменная не меняется, а задаёт поведение. Вы пишете общий алгоритм один раз, а наружу отдаёте набор специализированных функций.

function multiplyBy(factor) {
  return (n) => n * factor;
}
const double = multiplyBy(2);
const triple = multiplyBy(3);
console.log(double(21), triple(double(5)));

double и triple — один и тот же код с разной памятью. Так удобно готовить форматтеры, валидаторы, логгеры: настройку передали один раз, дальше вызываете короткой функцией без лишних аргументов.

function withPrefix(prefix) {
  return (text) => `${prefix}: ${text}`;
}
const warn = withPrefix("ВНИМАНИЕ");
console.log(warn("низкий заряд"));

Замыкание — не магия. Функция просто помнит, где она родилась, и держит эту комнату открытой.

const withVar = [];
for (var i = 0; i < 3; i++) withVar.push(() => i);
console.log(withVar[0](), withVar[1](), withVar[2]());
const withLet = [];
for (let j = 0; j < 3; j++) withLet.push(() => j);
console.log(withLet[0](), withLet[1](), withLet[2]());

Частичное применение — это фабрика, доведённая до общего вида: мы запоминаем несколько первых аргументов, а остальные примем позже. Запомненные значения живут в замыкании возвращённой функции.

function partial(fn, ...fixed) {
  return (...rest) => fn(...fixed, ...rest);
}
const pow = (base, exp) => base ** exp;
const powOf2 = partial(pow, 2);
console.log(powOf2(10), powOf2(3));

Каррирование — родственный приём: функция от нескольких аргументов превращается в цепочку функций от одного. Каждое звено цепочки помнит свой аргумент, и результат появляется только в конце.

const add = (x) => (y) => (z) => x + y + z;
const add10 = add(10);
console.log(add(1)(2)(3), add10(5)(1));

Промежуточные звенья вроде add10 — обычные значения: их можно передавать, складывать в массив, вызывать позже. Именно поэтому такой стиль удобен там, где функции передают друг другу: map, обработчики событий, конвейеры.

Если функция для одного и того же аргумента всегда даёт один и тот же ответ, ответ можно запомнить. Кэш держим в замыкании — он не мешает никому снаружи и не может быть случайно затёрт.

function makeSquare() {
  const cache = new Map();
  let calls = 0;
  const square = (n) => {
    if (!cache.has(n)) { calls += 1; cache.set(n, n * n); }
    return cache.get(n);
  };
  return { square, calls: () => calls };
}
const { square, calls } = makeSquare();
console.log(square(9), square(9), square(9), calls());

Счётчик внутри фабрики — доказательство: настоящее вычисление произошло один раз, остальные два вызова вернули готовое. Ни до кэша, ни до счётчика снаружи не дотянуться: они остались в замыкании, наружу торчат только две функции. Важное условие — функция должна быть чистой: мемоизировать что-то, зависящее от времени или от сети, нельзя, вы законсервируете старый ответ.

const memoize = (fn, store = new Map()) => (...args) => {
  const key = JSON.stringify(args);
  if (!store.has(key)) store.set(key, fn(...args));
  return store.get(key);
};
const sum = memoize((p, q) => p + q);
console.log(sum(2, 3), sum(2, 3));

Инициализация, отправка формы, показ подсказки — есть действия, которые обязаны случиться ровно один раз, сколько бы раз их ни попросили. Обёртка хранит в замыкании флаг и готовый результат.

function once(fn) {
  let result;
  return (...args) => {
    if (fn) { result = fn(...args); fn = null; }
    return result;
  };
}
const start = once((n) => "старт " + n);
console.log(start(1), start(2));

Вместо отдельного флага мы используем саму переменную fn: после первого вызова в ней null, проверка if (fn) больше не проходит. Заодно исходная функция освобождается — ссылки на неё в замыкании не остаётся.

Второй вызов вернул «старт 1», а не «старт 2», и это не ошибка: аргументы второго вызова просто игнорируются. Если такое поведение вас не устраивает — верните undefined или бросьте ошибку, решение за вами.

Пока жива функция, живо и всё, до чего она может дотянуться. Обычно это ровно то, что нужно, — но иногда в памяти застревает мегабайт, который вам уже не нужен.

function makeLeaky() {
  const huge = new Array(1e6).fill("x");
  return () => huge.length; // весь массив жив, пока жива эта функция
}
const f = makeLeaky();
console.log(f());

Лечится это скучно и надёжно: доставайте из большого объекта то немногое, что нужно, и запоминайте только его. Тогда после выхода из фабрики массив никем не удерживается и сборщик мусора его заберёт.

function makeLight() {
  const huge = new Array(1e6).fill("x");
  const size = huge.length; // запомнили число, а не массив
  return () => size;
}
console.log(makeLight()());

Тот же счёт применим к мемоизации: кэш внутри замыкания растёт бесконечно, если ключи всё время новые. Для долгоживущих функций ограничивайте размер кэша или чистите его — иначе оптимизация превратится в утечку.