Kurs JavaScript i TypeScript · Moduł 12: Programowanie funkcyjne

Domknięcia w programowaniu funkcyjnym

6 min czytania ·
W tej lekcji4

Licznik incydentów trzymany w zmiennej globalnej może zmienić każdy fragment kodu: skrypt raportu, stary moduł ochrony, literówka stażysty. Kiedy licznik pokaże bzdurę, nie wiadomo, kogo pytać. Potrzebujemy zmiennej, do której dostęp mają tylko wybrane funkcje.

W Parku Jurajskim każdy wybieg ma swój własny system zabezpieczeń - napięcie ogrodzenia, poziom alarmowy, licznik incydentów. Te dane są prywatne i niedostępne z zewnątrz, ale funkcje zarządzające wybiegiem mają do nich pełny dostęp. Dokładnie tak działają domknięcia (closures) - tworzą prywatne środowisko dla danych, dostępne tylko przez określone funkcje.

Czym jest domknięcie?

Domknięcie (closure) to funkcja, która "pamięta" zmienne z zakresu (scope), w którym została stworzona, nawet po tym, jak ten zakres przestał istnieć.

W JavaScript każda funkcja w chwili utworzenia zapamiętuje swoje otoczenie leksykalne, czyli zmienne widoczne w miejscu, w którym zapisano ją w kodzie. Najprostszy przykład to licznik:

function createCounter() {
  let count = 0; // Zmienna prywatna - niedostępna z zewnątrz

  return {
    increment() { count++; return count; },
    decrement() { count--; return count; },
    getCount() { return count; },
  };
}

const counter = createCounter();
counter.increment(); // 1
counter.increment(); // 2
counter.getCount();  // 2
// count jest całkowicie prywatna - nie ma do niej bezpośredniego dostępu

Wywołanie createCounter dawno się zakończyło, a count wciąż żyje, bo trzy metody trzymają do niej odniesienie. counter.count zwróci undefined, ponieważ zmienna nie jest właściwością obiektu, tylko częścią domknięcia. Domknięcie pamięta samą zmienną, a nie kopię jej wartości, dlatego drugie increment widzi wynik pierwszego. Metody licznika nie są czyste, bo zmieniają count, ale ta zmiana jest zamknięta w jednym miejscu.

Prywatność danych przez domknięcia

Domknięcia pozwalają tworzyć prawdziwie prywatne zmienne w JavaScript - to kluczowy wzorzec w programowaniu funkcyjnym. Zbudujmy system bezpieczeństwa wybiegu w dwóch krokach. Najpierw wnętrze sejfu, czyli prywatny stan i pomocnicza funkcja:

function createSecuritySystem(zoneName) {
  let fenceVoltage = 10000;
  let alertLevel = 0;
  let incidentLog = [];

  // Prywatna funkcja pomocnicza
  function logEvent(event) {
    incidentLog.push({ event, time: Date.now(), zone: zoneName });
  }

  // ...ciąg dalszy w następnym bloku

Trzy zmienne let i funkcja logEvent istnieją tylko wewnątrz jednego wywołania fabryki. Nie zwracamy ich, więc z zewnątrz nie da się ich ani odczytać, ani zmienić.

Na zewnątrz wychodzi wyłącznie obiekt z trzema metodami. To jedyne drzwi do sejfu:

  return {
    raiseFence() {
      fenceVoltage += 2000;
      logEvent('Fence voltage raised to ' + fenceVoltage);
      return fenceVoltage;
    },
    triggerAlert() {
      alertLevel++;
      logEvent('Alert level: ' + alertLevel);
      return alertLevel;
    },
    getStatus() {
      return {
        zone: zoneName,
        voltage: fenceVoltage,
        alert: alertLevel,
        incidents: incidentLog.length,
      };
    },
  };
}

Każda metoda widzi prywatne zmienne i logEvent, ale sama decyduje, co udostępnić: getStatus podaje liczbę incydentów, a nie samą tablicę dziennika. Sprawdźmy, czy dwa wybiegi naprawdę mają osobne sejfy:

const zoneA = createSecuritySystem('Zone A');
const zoneB = createSecuritySystem('Zone B');

zoneA.raiseFence();  // 12000
zoneA.triggerAlert(); // 1
zoneB.getStatus();   // { zone: 'Zone B', voltage: 10000, alert: 0, incidents: 0 }
// Każda strefa ma własne, izolowane dane

zoneA podniosła napięcie i ogłosiła alarm, a zoneB nic o tym nie wie, bo każde wywołanie fabryki tworzy nowe, niezależne domknięcie. Uważaj na jedną furtkę: gdyby metoda zwracała samą tablicę incidentLog, kod z zewnątrz dostałby odniesienie do oryginału i mógłby dopisywać do niej przez push. Zwracaj kopię, na przykład [...incidentLog]. Klasy mają pola prywatne ze znakiem #, znane Ci z modułu o klasach, a domknięcia dają ten sam efekt bez klas.

Fabryki funkcji (Function Factories)

Domknięcia są idealne do tworzenia fabryk - funkcji, które produkują wyspecjalizowane funkcje. Najmniejsza fabryka przyjmuje próg i zwraca predykat, który go pamięta:

function createFilter(minValue) {
  return (item) => item.value >= minValue;
}

const isStrongSignal = createFilter(70);
isStrongSignal({ value: 85 }); // true
isStrongSignal({ value: 12 }); // false

Każde wywołanie createFilter daje nowy filtr z własnym progiem, gotowy do przekazania metodzie filter. Fabryka może też zamknąć w sobie cały zestaw reguł. Object.entries zamienia obiekt reguł na tablicę par [pole, reguła], po której przechodzi pętla for...of:

// Fabryka walidatorów
function createValidator(rules) {
  return function validate(data) {
    const errors = [];
    for (const [field, rule] of Object.entries(rules)) {
      const value = data[field];
      if (rule.required && (value === undefined || value === '')) {
        errors.push(field + ' is required');
      }
      if (rule.min !== undefined && value < rule.min) {
        errors.push(field + ' must be >= ' + rule.min);
      }
      if (rule.max !== undefined && value > rule.max) {
        errors.push(field + ' must be <= ' + rule.max);
      }
    }
    return { valid: errors.length === 0, errors };
  };
}

const validateDinosaur = createValidator({
  name: { required: true },
  weight: { required: true, min: 1, max: 100000 },
  health: { required: true, min: 0, max: 100 },
});

validateDinosaur({ name: 'Rex', weight: 8000, health: 95 });
// { valid: true, errors: [] }

validateDinosaur({ name: '', weight: -5, health: 150 });
// { valid: false, errors: ['name is required', 'weight must be >= 1', 'health must be <= 100'] }

Zwróć uwagę na porównania z undefined zamiast skrótu w stylu rule.min && .... Reguła min: 0 to wartość fałszywa (falsy), więc skrót po cichu by ją pominął, a warunek !value uznałby zdrowie równe 0 za brak danych. Wewnątrz validate działa push, ale tylko na lokalnej tablicy errors, więc z zewnątrz funkcja pozostaje czysta.

Memoizacja z domknięciami

Memoizacja to technika cachowania wyników kosztownych obliczeń. Domknięcia zapewniają prywatny cache. Kluczem w Map jest tekst z JSON.stringify(args), bo dwie różne tablice argumentów nigdy nie są sobie równe jako obiekty:

function memoize(fn) {
  const cache = new Map();

  return function(...args) {
    const key = JSON.stringify(args);
    if (cache.has(key)) {
      console.log('Cache hit for:', key);
      return cache.get(key);
    }
    const result = fn(...args);
    cache.set(key, result);
    return result;
  };
}

Sprawdźmy teraz memoizację na analizie próbki DNA, która symuluje kosztowne obliczenie pętlą ze stu tysiącami kroków:

// Kosztowna analiza DNA
function analyzeDNA(sampleId, depth) {
  // Symulacja długiego obliczenia
  let result = 0;
  for (let i = 0; i < depth * 1000; i++) {
    result += Math.sqrt(i);
  }
  return { sampleId, score: result / (depth * 1000) };
}

const memoizedAnalyze = memoize(analyzeDNA);
memoizedAnalyze('TREX-001', 100); // oblicza
memoizedAnalyze('TREX-001', 100); // z cache - natychmiastowo!

Drugie wywołanie wypisuje Cache hit for: ["TREX-001",100] i oddaje zapamiętany wynik bez liczenia. Memoizuj wyłącznie czyste funkcje: gdyby analiza losowała wynik przez Math.random(), cache zamroziłby pierwsze losowanie i kolejne wywołania by kłamały. Dlatego symulacja korzysta tu z deterministycznego Math.sqrt.

W kodzie spotkasz też krótszą wersję na zwykłym obiekcie i operatorze ||= (logiczne przypisanie OR z ES2021):

const memoize = (fn) => {
  const cache = {};
  return (...args) => cache[args] ||= fn(...args);
};

cache[args] zamienia tablicę argumentów na tekst, np. 'TREX-001,100', a ||= przypisuje wynik tylko wtedy, gdy pod kluczem jest wartość fałszywa. Wada: wynik równy 0, '' lub false będzie liczony za każdym razem od nowa. Dlatego polecam Ci wersję z Map - jest dłuższa, ale wolna od tej pułapki. Domknięcia napędzają też currying z poprzedniej lekcji, a w następnej poznasz rekurencję.

Pamiętaj: domknięcie to sejf wybiegu - funkcja nosi ze sobą klucz do zmiennych z miejsca, w którym powstała, a reszta parku widzi tylko drzwi, które sam zamontujesz.

Kod do tej lekcji: index.js
// Domkniecia w programowaniu funkcyjnym
console.log("=== Park Jurajski - Prywatne Systemy Bezpieczenstwa ===\n");

// --- PRZYKLAD 1: Prywatnosc danych ---
console.log("--- Prywatnosc danych ---");

function createSecuritySystem(zoneName) {
  let fenceVoltage = 10000;
  let alertLevel = 0;
  const incidentLog = [];

  function logEvent(event) {
    incidentLog.push({ event, zone: zoneName, time: Date.now() });
  }

  return {
    raiseFence() {
      fenceVoltage += 2000;
      logEvent("Fence raised to " + fenceVoltage);
      return fenceVoltage;
    },
    triggerAlert() {
      alertLevel++;
      logEvent("Alert: " + alertLevel);
      return alertLevel;
    },
    getStatus() {
      return {
        zone: zoneName,
        voltage: fenceVoltage,
        alert: alertLevel,
        incidents: incidentLog.length,
      };
    },
  };
}

const zoneA = createSecuritySystem("Zone A");
const zoneB = createSecuritySystem("Zone B");

zoneA.raiseFence();
zoneA.raiseFence();
zoneA.triggerAlert();

console.log("Zone A:", zoneA.getStatus());
console.log("Zone B:", zoneB.getStatus());
console.log("Kazda strefa ma izolowane dane!\n");

// --- PRZYKLAD 2: Fabryka walidatorow ---
console.log("--- Fabryka walidatorow ---");

function createValidator(rules) {
  return function validate(data) {
    const errors = [];
    for (const [field, rule] of Object.entries(rules)) {
      if (rule.required && !data[field]) {
        errors.push(field + " is required");
      }
      if (rule.min !== undefined && data[field] < rule.min) {
        errors.push(field + " must be >= " + rule.min);
      }
      if (rule.max !== undefined && data[field] > rule.max) {
        errors.push(field + " must be <= " + rule.max);
      }
    }
    return { valid: errors.length === 0, errors };
  };
}

const validateDino = createValidator({
  name: { required: true },
  weight: { required: true, min: 1, max: 100000 },
  health: { required: true, min: 0, max: 100 },
});

console.log("Valid:", validateDino({ name: "Rex", weight: 8000, health: 95 }));
console.log("Invalid:", validateDino({ name: "", weight: -5, health: 150 }));

// --- PRZYKLAD 3: Memoizacja ---
console.log("\n--- Memoizacja ---");

function memoize(fn) {
  const cache = new Map();
  return function(...args) {
    const key = JSON.stringify(args);
    if (cache.has(key)) {
      console.log("  Cache HIT:", key);
      return cache.get(key);
    }
    console.log("  Computing:", key);
    const result = fn(...args);
    cache.set(key, result);
    return result;
  };
}

function expensiveAnalysis(species, depth) {
  let sum = 0;
  for (let i = 0; i < depth * 100; i++) sum += i;
  return { species, score: sum };
}

const memoAnalysis = memoize(expensiveAnalysis);
memoAnalysis("T-Rex", 10);     // Computing
memoAnalysis("T-Rex", 10);     // Cache HIT
memoAnalysis("Raptor", 5);     // Computing
memoAnalysis("Raptor", 5);     // Cache HIT
memoAnalysis("T-Rex", 10);     // Cache HIT

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Czym jest domknięcie (closure) w JavaScript?

  2. 2. Czym jest memoizacja w kontekście programowania funkcyjnego?

To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Edytor kodu

    Zbuduj fabrykę trackerów incydentów z prywatnymi danymi i funkcję memoize.

  • Układanie w poziomie

    Ułóż elementy fabryki funkcji z domknięciem:

  • Edytor kodu

    Przepisz imperatywne pętle for na filter, map i reduce z użyciem pipe.

  1. PytanieDomknięcie (closure)
  2. PytanieMemoizacja
  3. Zadanie z kodemDomknięcia - prywatne dane i fabryki
  4. Ułóż w kolejnościSkładnia fabryki funkcji
  5. PytaniePrywatność danych z closure
  6. Zadanie z kodemRefactoring do stylu funkcyjnego

Przydatne artykuły