Kurs JavaScript i TypeScript · Moduł 12: Programowanie funkcyjne
Domknięcia w programowaniu funkcyjnym
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ępuWywoł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 blokuTrzy 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 danezoneA 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 }); // falseKaż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 HITHasł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. Czym jest domknięcie (closure) w JavaScript?
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.