Kurs JavaScript i TypeScript · Moduł 2: Funkcje, tablice i obiekty
Closures i zakres leksykalny
W tej lekcji7
W Parku Jurajskim każdy wybieg ma ogrodzenie, a każde laboratorium drzwi z kodem dostępu. Podobnie działa zakres (scope) w JavaScript: to niewidzialne ogrodzenie, które decyduje, które zmienne są dostępne w danym miejscu kodu. Jest też problem: jak zbudować licznik obserwacji, którego żaden inny system nie wyzeruje przez pomyłkę? Zmienna globalna jest dostępna dla wszystkich. Rozwiązaniem są closures (domknięcia), czyli dinozaur, który pamięta kod PIN do swojego wybiegu, nawet gdy strażnik dawno odszedł.
Zakres leksykalny (Lexical Scope)
JavaScript używa zakresu leksykalnego: dostęp do zmiennych zależy od miejsca, w którym kod został napisany, a nie od tego, gdzie został wywołany. Wyobraź sobie mapę parku: każdy wybieg (funkcja) widzi główną drogę (zakres globalny) i własne terytorium, ale nie widzi wnętrza innych wybiegów.
// Zakres globalny - główna droga Parku Jurajskiego
const parkName = "Jurassic Park";
function enclosureA() {
// Zakres funkcji enclosureA - Wybieg A
const dinosaurA = "Tyrannosaurus Rex";
console.log(parkName); // "Jurassic Park" - widzi zakres globalny
console.log(dinosaurA); // "Tyrannosaurus Rex" - widzi swój zakres
function innerFence() {
// Zakres zagnieżdżony - wewnętrzne ogrodzenie
const babyDino = "Baby Rex";
console.log(parkName); // "Jurassic Park" - widzi zakres globalny
console.log(dinosaurA); // "Tyrannosaurus Rex" - widzi zakres rodzica
console.log(babyDino); // "Baby Rex" - widzi swój zakres
}
innerFence();
// console.log(babyDino); // BŁĄD! Nie widzi wnętrza innerFence
}
function enclosureB() {
// Zakres funkcji enclosureB - Wybieg B
const dinosaurB = "Triceratops";
console.log(parkName); // "Jurassic Park" - widzi zakres globalny
// console.log(dinosaurA); // BŁĄD! Nie widzi wnętrza enclosureA
}Zasada jest prosta: funkcja wewnętrzna widzi zmienne funkcji zewnętrznej, ale nie odwrotnie. Dinozaur w wewnętrznym wybiegu widzi przez ogrodzenie na zewnątrz, a strażnik z zewnątrz nie zajrzy przez podwójne ściany do środka. Dlatego innerFence odczytuje dinosaurA bez przekazywania argumentu, a enclosureB nie ma do niej dostępu.
Czym jest Closure (Domknięcie)?
Closure to funkcja, która "pamięta" zmienne z zakresu, w którym powstała, nawet gdy ten zakres zakończył działanie. Zobacz to na trackerze obserwacji:
function createDinoTracker(species) {
// Zmienna "species" jest w zakresie createDinoTracker
let sightings = 0;
// Ta funkcja wewnętrzna tworzy CLOSURE
// - "pamięta" species i sightings, nawet po zakończeniu createDinoTracker
return function reportSighting(location) {
sightings++;
console.log(species + " widziany w: " + location + " (obserwacja #" + sightings + ")");
};
}
// createDinoTracker zakończyło działanie, ale zwrócona funkcja PAMIĘTA zmienne
const trackRex = createDinoTracker("T-Rex");
const trackRaptor = createDinoTracker("Velociraptor");
trackRex("Sektor A"); // "T-Rex widziany w: Sektor A (obserwacja #1)"
trackRex("Sektor B"); // "T-Rex widziany w: Sektor B (obserwacja #2)"
trackRaptor("Laboratorium"); // "Velociraptor widziany w: Laboratorium (obserwacja #1)"
// Każde closure ma WŁASNĄ kopię zmiennych!
// trackRex ma swoje sightings = 2, trackRaptor ma swoje sightings = 1Każde wywołanie createDinoTracker tworzy nowy zakres, więc liczniki obu trackerów są niezależne. Z zewnątrz nikt nie zmieni sightings, bo zmienna nie jest widoczna poza funkcją. Mechanizm przebiega w pięciu krokach:
- Definiujesz funkcję zewnętrzną z lokalnymi zmiennymi.
- W środku definiujesz funkcję wewnętrzną, która z nich korzysta.
- Funkcja zewnętrzna zwraca funkcję wewnętrzną przez
return. - Wywołujesz funkcję zewnętrzną i zapisujesz wynik do zmiennej.
- Wywołujesz zwróconą funkcję, a ona wciąż ma dostęp do zmiennych zewnętrznych.
Praktyczne zastosowania closures
Prywatność danych (enkapsulacja)
Closures pozwalają tworzyć prywatne zmienne, do których nie dostanie się nikt z zewnątrz. Jak system bezpieczeństwa parku, w którym kody dostępu są ukryte w zamkniętej szafie:
function createSecuritySystem(enclosureName) {
// Te zmienne są PRYWATNE - niedostępne z zewnątrz
let accessCode = Math.floor(Math.random() * 9000) + 1000;
let isLocked = true;
const accessLog = [];
return {
unlock(code) {
if (code === accessCode) {
isLocked = false;
accessLog.push("Odblokowano: " + new Date().toLocaleTimeString());
console.log(enclosureName + " - ogrodzenie WYŁĄCZONE");
} else {
accessLog.push("Nieudana próba: " + new Date().toLocaleTimeString());
console.log(enclosureName + " - BŁĘDNY KOD!");
}
},
lock() {
isLocked = true;
accessLog.push("Zablokowano: " + new Date().toLocaleTimeString());
console.log(enclosureName + " - ogrodzenie WŁĄCZONE");
},
getStatus() {
return isLocked ? "ZAMKNIĘTY" : "OTWARTY";
},
getLog() {
return [...accessLog]; // Zwraca kopię, nie oryginał
}
};
}
const rexSecurity = createSecuritySystem("Wybieg T-Rex");
// Nie ma sposobu, by bezpośrednio odczytać accessCode!
// rexSecurity.accessCode → undefined (prywatna zmienna)Zwrócony obiekt ma tylko cztery metody. accessCode, isLocked i accessLog nie są jego właściwościami, lecz zmiennymi z domknięcia, więc zmienić je mogą wyłącznie te metody. getLog() oddaje kopię tablicy, więc wyczyszczenie wyniku nie ruszy prawdziwego dziennika.
Fabryki funkcji (Function Factories)
Closures umożliwiają tworzenie fabryk, czyli funkcji produkujących inne funkcje z wbudowaną konfiguracją. Jak laboratorium genetyczne, które tworzy dinozaury z określonym DNA:
function createDinoFilter(property, value) {
// Closure "zapamiętuje" property i value
return function(dinosaur) {
return dinosaur[property] === value;
};
}
const isCarnivore = createDinoFilter("diet", "carnivore");
const isHerbivore = createDinoFilter("diet", "herbivore");
const isSectorA = createDinoFilter("sector", "A");
const dinosaurs = [
{ name: "Rex", diet: "carnivore", sector: "A" },
{ name: "Tricia", diet: "herbivore", sector: "B" },
{ name: "Blue", diet: "carnivore", sector: "C" }
];
console.log(dinosaurs.filter(isCarnivore)); // Rex, Blue
console.log(dinosaurs.filter(isHerbivore)); // Tricia
console.log(dinosaurs.filter(isSectorA)); // RexTrzy filtry powstały z jednej fabryki, a każdy pamięta własną parę property i value. Najmniejsza fabryka mieści się w trzech liniach:
function createMultiplier(factor) {
return n => n * factor;
}
const double = createMultiplier(2);
const triple = createMultiplier(3);
console.log(double(5)); // 10
console.log(triple(4)); // 12Funkcja strzałkowa zapamiętuje factor, więc double i triple mają ten sam kod, ale różną konfigurację.
IIFE - Immediately Invoked Function Expressions
IIFE (natychmiast wywoływane wyrażenie funkcyjne) to funkcja definiowana i od razu wykonywana. To jednorazowy protokół bezpieczeństwa: uruchamia się, robi swoje i znika, nie zostawiając śladów w zakresie globalnym.
// Składnia IIFE
(function() {
const secretData = "Lokalizacja ukrytego laboratorium";
console.log("IIFE wykonane! Dane: " + secretData);
})();
// secretData nie istnieje w zakresie globalnym!
// IIFE ze strzałką
(() => {
const emergencyProtocol = "Ewakuacja sektora 7";
console.log("Protokół awaryjny aktywowany: " + emergencyProtocol);
})();
// IIFE z parametrami
const dinoReport = (function(parkData) {
const processed = parkData.map(d => d.toUpperCase());
return processed.join(", ");
})(["rex", "raptor", "triceratops"]);
console.log(dinoReport); // "REX, RAPTOR, TRICERATOPS"Budowa jest zawsze ta sama: nawias otwierający, function(), ciało { /* kod */ }, nawias zamykający i (), które wywołuje funkcję. Nawias wokół funkcji zamienia ją w wyrażenie, bez niego silnik zgłosi błąd składni. Gdy IIFE zwróci obiekt z metodami, otrzymasz moduł z prywatnym stanem:
const visitorCounter = (function() {
let count = 0; // prywatny stan modułu
return {
increment() { return ++count; },
getValue() { return count; }
};
})();
visitorCounter.increment(); // 1
visitorCounter.increment(); // 2
console.log(visitorCounter.getValue()); // 2IIFE były bardzo popularne przed ES6, gdy var nie miał zakresu blokowego. Dziś nadal izolują kod, ale w nowym projekcie polecam moduły ES z import i export, a IIFE warto rozpoznawać w starszym kodzie.
Hoisting - var vs let/const
Hoisting (wynoszenie) to mechanizm, w którym deklaracje zmiennych i funkcji są "przenoszone" na początek swojego zakresu. Każde słowo kluczowe zachowuje się jednak inaczej:
// var - hoisting z wartością undefined
console.log(dinoVar); // undefined (nie błąd!)
var dinoVar = "Stegosaurus";
console.log(dinoVar); // "Stegosaurus"
// let/const - hoisting ale z "Temporal Dead Zone" (TDZ)
// console.log(dinoLet); // ReferenceError! Zmienna w TDZ
let dinoLet = "Ankylosaurus";
console.log(dinoLet); // "Ankylosaurus"
// const - tak samo jak let, plus wymaga natychmiastowej inicjalizacji
// console.log(dinoConst); // ReferenceError! TDZ
const dinoConst = "Brachiosaurus";Zmienna z let istnieje od początku bloku, ale do linii deklaracji leży w strefie zakazu wstępu, więc odczyt kończy się ReferenceError, a nie wartością undefined czy null.
var vs let w pętlach - klasyczna pułapka
To jeden z najsłynniejszych problemów JavaScript, gdzie closures i var dają nieoczekiwane wyniki:
// Problem z var - wszystkie closures dzielą tę samą zmienną
for (var i = 0; i < 3; i++) {
setTimeout(function() {
console.log("var: Dinozaur #" + i); // Zawsze "Dinozaur #3"!
}, 100);
}
// Rozwiązanie z let - każda iteracja ma własną kopię
for (let j = 0; j < 3; j++) {
setTimeout(function() {
console.log("let: Dinozaur #" + j); // 0, 1, 2 - poprawnie!
}, 100);
}Dlaczego var nie działa? Ma zakres funkcyjny, więc trzy closures odwołują się do jednej zmiennej i, która po pętli ma wartość 3. let ma zakres blokowy i każda iteracja tworzy nową zmienną j. Zanim pojawiło się let, ratowano się IIFE, które zamraża bieżącą wartość:
// Starsze rozwiązanie: IIFE przechwytuje bieżącą wartość
for (var k = 0; k < 3; k++) {
(function(captured) {
setTimeout(function() {
console.log("IIFE: Dinozaur #" + captured); // 0, 1, 2
}, 100);
})(k);
}Działa, ale let robi to samo bez dodatkowej funkcji, więc to jego wybieraj.
Podsumowanie
| Koncept | Analogia w Parku Jurajskim |
|---|---|
| Zakres globalny | Główna droga parku - widoczna ze wszystkich wybiegów |
| Zakres funkcji | Wybieg dinozaura - widzi na zewnątrz, ale nikt nie widzi do środka |
| Closure | Dinozaur pamięta układ parku nawet po przebudowie ogrodzeń |
| Prywatne zmienne | Kod PIN do ogrodzenia - ukryty w zamkniętym systemie |
| IIFE | Jednorazowy protokół bezpieczeństwa - wykonaj i zapomnij |
| Hoisting var | Dinozaur, który pojawia się na liście przed wykluciem z jaja |
| TDZ (let/const) | Strefa zakazu wstępu do momentu oficjalnego otwarcia wybiegu |
Closures wrócą w module o asynchroniczności, bo każdy callback przekazany do setTimeout czy obietnicy korzysta z domknięcia.
Praktyka
W piaskownicy czekają zakres leksykalny, tracker obserwacji i system bezpieczeństwa z prywatnym dziennikiem. Wywołaj trackery kilka razy i sprawdź, że każdy liczy osobno.
Kod do tej lekcji: index.js
// Closures i zakres leksykalny - Park Jurajski
console.log("=== CLOSURES W PARKU JURAJSKIM ===\n");
// ================================================
// 1. ZAKRES LEKSYKALNY - ogrodzenia parku
// ================================================
console.log("--- 1. Zakres leksykalny ---");
const parkName = "Jurassic Park"; // Zakres globalny
function enclosureA() {
const dinosaurA = "Tyrannosaurus Rex"; // Zakres enclosureA
function innerFence() {
const babyDino = "Baby Rex"; // Zakres innerFence
// Widzi WSZYSTKO: swoje zmienne + rodzica + globalne
console.log("innerFence widzi: " + parkName + ", " + dinosaurA + ", " + babyDino);
}
innerFence();
// console.log(babyDino); // BLAD! Nie widzi wnetrza innerFence
console.log("enclosureA widzi: " + parkName + ", " + dinosaurA);
}
enclosureA();
// ================================================
// 2. CLOSURE - dinozaur pamieta swoje otoczenie
// ================================================
console.log("\n--- 2. Closure - tracker dinozaurow ---");
function createDinoTracker(species) {
let sightings = 0; // Ta zmienna zyje w closure!
return function reportSighting(location) {
sightings++; // Closure pamięta i modyfikuje sightings
console.log(species + " widziany w: " + location + " (obserwacja #" + sightings + ")");
};
}
const trackRex = createDinoTracker("T-Rex");
const trackRaptor = createDinoTracker("Velociraptor");
trackRex("Sektor A");
trackRex("Sektor B");
trackRaptor("Laboratorium");
trackRex("Sektor C");
// Kazdy tracker ma WLASNA kopie zmiennej sightings!
// ================================================
// 3. PRYWATNOSC DANYCH - system bezpieczenstwa
// ================================================
console.log("\n--- 3. Prywatne zmienne (enkapsulacja) ---");
function createSecuritySystem(enclosureName) {
let isLocked = true; // PRYWATNA zmienna
const log = [];
return {
unlock() {
isLocked = false;
log.push("Odblokowano o " + new Date().toLocaleTimeString());
console.log(enclosureName + " - ogrodzenie WYLACZONE");
},
lock() {
isLocked = true;
log.push("Zablokowano o " + new Date().toLocaleTimeString());
console.log(enclosureName + " - ogrodzenie WLACZONE");
},
getStatus() {
return enclosureName + ": " + (isLocked ? "ZAMKNIETY" : "OTWARTY");
},
getLog() { return [...log]; }
};
}
const rexSecurity = createSecuritySystem("Wybieg T-Rex");
console.log(rexSecurity.getStatus());
rexSecurity.unlock();
console.log(rexSecurity.getStatus());
rexSecurity.lock();
console.log("Log:", rexSecurity.getLog());
// rexSecurity.isLocked -> undefined (prywatna!)
// ================================================
// 4. FABRYKA FUNKCJI
// ================================================
console.log("\n--- 4. Fabryka funkcji ---");
function createDinoFilter(property, value) {
return function(dinosaur) {
return dinosaur[property] === value;
};
}
const dinosaurs = [
{ name: "Rex", diet: "carnivore", sector: "A" },
{ name: "Tricia", diet: "herbivore", sector: "B" },
{ name: "Blue", diet: "carnivore", sector: "C" },
{ name: "Steggy", diet: "herbivore", sector: "A" }
];
const isCarnivore = createDinoFilter("diet", "carnivore");
const isSectorA = createDinoFilter("sector", "A");
console.log("Miesozercy:", dinosaurs.filter(isCarnivore).map(d => d.name));
console.log("Sektor A:", dinosaurs.filter(isSectorA).map(d => d.name));
// ================================================
// 5. IIFE - jednorazowy protokol
// ================================================
console.log("\n--- 5. IIFE ---");
const emergencyReport = (function(dinos) {
const carnivores = dinos.filter(d => d.diet === "carnivore");
const herbivores = dinos.filter(d => d.diet === "herbivore");
return "Raport: " + carnivores.length + " miesozercow, " + herbivores.length + " roslinozercy";
})(dinosaurs);
console.log(emergencyReport);
// ================================================
// 6. HOISTING - var vs let
// ================================================
console.log("\n--- 6. Hoisting ---");
// var - hoisting z undefined
console.log("var przed deklaracja:", typeof dinoVar); // undefined
var dinoVar = "Stegosaurus";
console.log("var po deklaracji:", dinoVar);
// let - Temporal Dead Zone
// console.log(dinoLet); // ReferenceError!
let dinoLet = "Ankylosaurus";
console.log("let po deklaracji:", dinoLet);
// var vs let w petli
console.log("\nPetla z let:");
for (let j = 0; j < 3; j++) {
setTimeout(() => console.log(" let: Dinozaur #" + j), 10);
}Zapamiętaj: closure to dinozaur, który pamięta swój wybieg, czyli funkcja zabierająca ze sobą zmienne z miejsca, w którym powstała.
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. Co zobaczymy w konsoli po wykonaniu poniższego kodu? function outer() { const x = 10; function inner() { console.log(x); } inner(); } outer();
2. Czym jest closure (domknięcie) w JavaScript?
3. Co się stanie, gdy spróbujemy użyć zmiennej zadeklarowanej przez let PRZED jej deklaracją? console.log(dinoName); let dinoName = "Rex";
Zadania praktyczne w grze
- Edytor kodu
Napisz funkcję createDinoTracker(species), która trzyma w domknięciu prywatny licznik sightings i tablicę history i zwraca obiekt z metodami: reportSighting(location) (zwiększa licznik i dopisuje lokalizację do historii), getSightings() (zwraca liczbę obserwacji) i getHistory() (zwraca kopię historii). Napisz też createEnclosure(name, maxCapacity) z prywatną tablicą residents i metodami: addDinosaur(dinoName) (dodaje dinozaura i zwraca true, a gdy brak miejsca, zwraca false), removeDinosaur(dinoName), getPopulation() (zwraca kopię tablicy) i getStatus() (zwraca tekst 'name: X/maxCapacity', np. 'Paddock T-Rex: 1/2').
- Układanie w pionie
Uporządkuj kroki powstawania i działania closure w JavaScript:
- Klikanie w kolejności
Zbuduj poprawne IIFE (Immediately Invoked Function Expression) klikając elementy w odpowiedniej kolejności:
- Edytor kodu
Napisz fabrykę createFilter(property, value), która zwraca funkcję sprawdzającą, czy obiekt[property] === value, oraz fabrykę createWeightConverter(multiplier), która zwraca funkcję mnożącą wagę w kilogramach przez multiplier. Następnie za pomocą IIFE utwórz licznik dinoCounter z prywatną zmienną count i metodami increment(), decrement() i getValue().