Kurs JavaScript i TypeScript · Moduł 2: Funkcje, tablice i obiekty

Hoisting w JavaScript

17 min czytania ·
W tej lekcji8

Witaj z powrotem w Parku Jurajskim! W lekcji o zasięgu zmiennych sprawdzaliśmy, gdzie żyje zmienna, czyli jaki ma zasięg. Dzisiaj odpowiemy na pytanie równie ważne: od którego momentu zmienna albo funkcja w ogóle istnieje. Mechanizm, który o tym decyduje, nazywa się hoistingiem, a jego znajomość chroni przed najbardziej podstępną kategorią błędów w systemach parku - takich, które niczego nie wysadzają w powietrze, tylko po cichu podają złą wartość. Zmienna, która istnieje, ale nic nie zawiera, bywa groźniejsza niż zmienna, której nie ma wcale.

Czym jest hoisting?

Hoisting (po polsku "wynoszenie") to zachowanie JavaScriptu polegające na przeniesieniu deklaracji zmiennych i funkcji na górę ich zasięgu - funkcyjnego albo globalnego - jeszcze w fazie kompilacji, zanim wykona się pierwsza linia kodu. Silnik najpierw przegląda cały kod i spisuje, jakie nazwy w nim występują, a dopiero potem zaczyna go wykonywać. Dzięki temu do części zmiennych i funkcji możemy odwołać się wcześniej, niż zostały zapisane w pliku.

To trochę jak spis inwentarza sporządzany, zanim dinozaury trafią do zagród: kompilator JavaScriptu najpierw notuje, "czego się spodziewać", a dopiero potem wykonuje konkretne operacje, linia po linii. Na górę wędrują wyłącznie deklaracje - nigdy wartości, które im przypisujemy.

Każda zmienna przechodzi ten sam cykl życia. Silnik najpierw parsuje kod, potem tworzy kontekst wykonania i rezerwuje w nim pamięć na zadeklarowane nazwy (to właśnie moment hoistingu), a dopiero wtedy wykonuje kod: zmienna dostaje wartość i jest używana. Gdy do wartości nie prowadzi już żadna referencja, sprzątaniem zajmuje się garbage collector. W fazie oznaczania (mark) zaznacza wszystko, do czego program nadal może dotrzeć, a resztę uznaje za przeznaczoną do usunięcia, po czym w fazie sprzątania (sweep) zwalnia jej pamięć.

Hoisting funkcji

Deklaracje funkcji wynoszone są w całości: razem z nazwą podróżuje też ciało funkcji. Możemy więc wywołać funkcję, zanim pojawi się w pliku. W zarządzaniu parkiem to bardzo wygodne, bo pozwala trzymać główną logikę na górze, a szczegóły techniczne spychać na dół.

// Możemy wywołać funkcję przed jej zdefiniowaniem
checkSecurity("Zagroda T-Rex");  // "Sprawdzam bezpieczeństwo: Zagroda T-Rex"

// Deklaracja funkcji jest hoistowana
function checkSecurity(location) {
  console.log(`Sprawdzam bezpieczeństwo: ${location}`);
  return true;
}

Działa to dlatego, że w fazie kompilacji JavaScript wynosi na górę zasięgu całą deklarację - nazwę wraz z ciałem. Zanim wykona się pierwsza instrukcja, checkSecurity jest już kompletną, gotową do wywołania funkcją, a nie pustym miejscem czekającym na uzupełnienie. To jedyny przypadek w całym języku, w którym na górę zasięgu trafia razem z nazwą także wartość, bo funkcja też jest wartością. Wszystkie pozostałe konstrukcje, które za chwilę zobaczymy, wynoszą samą nazwę i nic poza nią.

Uwaga na wyrażenia funkcyjne!

W całości wynoszone są tylko deklaracje funkcji. Wyrażenia funkcyjne, czyli funkcje przypisane do zmiennej, podlegają regułom hoistingu zmiennych: sama zmienna trafia na górę, ale przypisana do niej funkcja już nie.

// To NIE zadziała prawidłowo
// feedDinosaur("Rex");  // TypeError: feedDinosaur is not a function

// Hoistowana jest tylko deklaracja zmiennej, nie przypisanie funkcji
var feedDinosaur = function(dinoName) {
  console.log(`Karmienie dinozaura: ${dinoName}`);
};

// Od tej linii możemy już wywołać funkcję
feedDinosaur("Rex");  // "Karmienie dinozaura: Rex"

Przeczytaj uważnie komunikat błędu, bo to cenna wskazówka. Nie dostajemy ReferenceError, tylko TypeError: feedDinosaur is not a function - nazwa feedDinosaur już istnieje, po prostu trzyma w tym momencie undefined, a undefined nie da się wywołać jak funkcji. Ta drobna różnica potrafi skrócić debugowanie z godziny do minuty: ReferenceError kieruje nas do literówki albo zapomnianego importu, a TypeError do kolejności linii w pliku. Deklaracja funkcji jest dostępna w całym swoim zasięgu, wyrażenie funkcyjne dopiero od linii z przypisaniem.

Funkcje strzałkowe działają tak samo

Funkcje strzałkowe również są wyrażeniami, więc ich ciało nigdy nie jest wynoszone. Ponieważ przypisujemy je zwykle do const albo let, błąd przy zbyt wczesnym wywołaniu okazuje się jeszcze bardziej stanowczy niż przy var.

// checkFence();  // ReferenceError: Cannot access checkFence before initialization

const checkFence = () => "Ogrodzenie OK";

console.log(checkFence());  // "Ogrodzenie OK"

Różnica jest istotna: przy var dostaliśmy TypeError, tutaj ReferenceError. Oba komunikaty znaczą to samo - "za wcześnie" - ale wersja z const zatrzymuje program dokładnie w miejscu pomyłki, zamiast puścić dalej wartość undefined, która wybuchnie kilkadziesiąt linii później, w zupełnie niewinnym fragmencie kodu. Stąd praktyczna reguła: przed linią definicji można używać wyłącznie funkcji zadeklarowanych przez function nazwa() {}. Wszystko, co przypisujemy do zmiennej - klasyczne wyrażenie funkcyjne czy strzałka - działa dopiero poniżej.

Hoisting zmiennych

Przy zmiennych hoisting zachowuje się różnie, zależnie od słowa kluczowego (var, let, const). Stąd bierze się większość niespodzianek, więc rozłóżmy oba przypadki na czynniki pierwsze.

Hoisting zmiennych deklarowanych przez var

Zmienne deklarowane przez var są wynoszone i od razu inicjalizowane wartością undefined, więc odczyt przed deklaracją jest w pełni legalny:

console.log(dinosaurCount);  // undefined (nie błąd!)
var dinosaurCount = 15;
console.log(dinosaurCount);  // 15

Nic się nie zepsuło - i na tym właśnie polega problem. Program leci dalej z wartością, której nikt nie zaplanował, a undefined w liczniku dinozaurów zamienia się w NaN w każdym obliczeniu, do którego trafi. Raport pokaże NaN zamiast liczby zwierząt w zagrodzie, w której siedzą trzy, i nikt nie dostanie żadnego ostrzeżenia. Łatwiej to zrozumieć, gdy wyobrazimy sobie, że przed uruchomieniem JavaScript przepisuje powyższy kod do takiej postaci:

var dinosaurCount;           // Hoisting - deklaracja wędruje na górę
console.log(dinosaurCount);  // undefined
dinosaurCount = 15;          // Przypisanie zostaje tam, gdzie je napisaliśmy
console.log(dinosaurCount);  // 15

Deklaracja wskoczyła na górę, przypisanie zostało dokładnie tam, gdzie je zapisaliśmy. Cała reguła hoistingu mieści się w jednym zdaniu: deklaracja wędruje w górę, wartość nie rusza się z miejsca. Odcinek między tymi dwoma punktami to okno, w którym zmienna jest osiągalna, ale pusta. Czujnik parku raportujący undefined wygląda w logach niepokojąco podobnie do czujnika, który nie raportuje niczego - a to dwie zupełnie różne sytuacje, jedna oznacza spokój, druga zerwane ogrodzenie.

Hoisting zmiennych deklarowanych przez let i const

Zmienne deklarowane przez let i const (wprowadzone w ES6) także są hoistowane, ale nie dostają wartości undefined. Zamiast tego trafiają do temporal dead zone, czyli martwej strefy czasowej - okresu od rozpoczęcia wykonywania bloku aż do linii, w której zmienna faktycznie zostaje zadeklarowana. Sięgnięcie po nią w tym czasie kończy się błędem.

// To spowoduje błąd:
// console.log(securityLevel);  // ReferenceError: Cannot access securityLevel before initialization
let securityLevel = "Wysoki";
console.log(securityLevel);  // "Wysoki"

// To samo dotyczy const:
// console.log(parkName);  // ReferenceError: Cannot access parkName before initialization
const parkName = "Jurassic Park";
console.log(parkName);  // "Jurassic Park"

Dwa komunikaty błędów trzeba umieć od siebie odróżnić:

  • zmienna, która nigdy nie została zadeklarowana: ReferenceError: xyz is not defined
  • zmienna let lub const w temporal dead zone: ReferenceError: Cannot access 'xyz' before initialization

To rozróżnienie jest prezentem dla debugującego. Pierwszy przypadek oznacza, że zmiennej nie ma nigdzie - najpewniej literówka albo zapomniany import. Drugi mówi, że zmienna istnieje, tylko sięgnęliśmy po nią za wcześnie, więc wystarczy przenieść odczyt poniżej deklaracji. Wyobraź sobie funkcję na dwieście linii, w której wartość jest czytana na górze, a przypisywana na dole: z var dostajemy ciche undefined i godzinę szukania po omacku, z let program zatrzymuje się natychmiast i wskazuje palcem konkretną linię. Temporal dead zone to nie ograniczenie, tylko system wczesnego ostrzegania.

Klasy też siedzą w temporal dead zone

Klasy zachowują się jak let i const, a nie jak deklaracje funkcji. Ich nazwa jest wynoszona, ale dopóki silnik nie wykona ciała klasy, każda próba użycia kończy się błędem.

// const dino = new Dinosaur("Rex");  // ReferenceError: Cannot access Dinosaur before initialization

class Dinosaur {
  constructor(name) {
    this.name = name;
  }
}

const dino = new Dinosaur("Rex");  // OK
console.log(dino.name);  // "Rex"

Reguła "funkcje można definiować poniżej miejsca użycia" nie rozciąga się więc na klasy - klasa musi powstać przed pierwszym new, które tworzy jej instancję. Jeśli z przyzwyczajenia zepchniesz definicję klasy na koniec pliku, to właśnie ten komunikat zobaczysz w konsoli, a lekarstwo jest banalne: przenieś klasę nad kod, który ją instancjonuje. W plikach parku daje to prostą kolejność - najpierw modele zwierząt i urządzeń, potem logika, która z nich korzysta, i nigdy odwrotnie.

Hoisting a zasięg zmiennych

Hoisting jest ściśle spleciony z zasięgiem zmiennych, nazywanym też ich zakresem. Deklaracje nie wędrują na górę pliku, tylko na górę swojego zasięgu, a to, który zasięg jest "swój", zależy od słowa kluczowego: var trzyma się zasięgu funkcyjnego, let i const - blokowego. W zasięgu globalnym reguła pozostaje ta sama, tyle że górą jest po prostu początek programu.

Przykład dla var (zasięg funkcyjny)

var całkowicie ignoruje klamry if-a czy pętli: deklaracja ląduje na górze funkcji, która ją zawiera, niezależnie od tego, w którym miejscu ją zapisaliśmy.

function monitorSystem() {
  console.log(systemStatus);  // undefined (hoisting w obrębie funkcji)

  if (true) {
    var systemStatus = "Online";
  }

  console.log(systemStatus);  // "Online"
}

monitorSystem();
// console.log(systemStatus);  // ReferenceError: systemStatus is not defined (poza zasięgiem funkcji)

Blok if w ogóle nie utworzył tutaj nowego zasięgu dla systemStatus. Deklaracja wskoczyła na górę monitorSystem, więc zmienną da się odczytać jeszcze przed blokiem (jest wtedy pusta), a po bloku trzyma już przypisaną wartość. Poza funkcją znika kompletnie, bo jedyną granicą, którą var respektuje, jest funkcja. Dwa console.log z tą samą nazwą dają zatem dwa różne wyniki - nie dlatego, że zmienne są dwie, tylko dlatego, że patrzymy na jedną zmienną raz przed przypisaniem, a raz po nim.

Pętle pokazują tę różnicę najwyraźniej

Najlepszym poligonem do porównania obu zasięgów są pętle, bo licznik jest w nich deklarowany i używany w jednym miejscu. Sprawdź, co zostaje po pętli, w której licznik powstaje przez var, a co po pętli z let.

for (var index = 0; index < 3; index++) {
  // obchód zagród
}
console.log(index);  // 3 - var przeżywa pętlę (zasięg funkcyjny)

for (let step = 0; step < 3; step++) {
  // obchód zagród
}
// console.log(step);  // ReferenceError - let zostaje w zasięgu blokowym

Po zakończeniu pierwszej pętli index nadal ma wartość 3, bo należy do zasięgu funkcyjnego i spokojnie przeżywa zamykającą klamrę. Zmienna step z drugiej pętli ma zasięg blokowy i znika razem z pętlą, więc odczyt poniżej kończy się błędem ReferenceError. Ta różnica stoi za słynnymi kłopotami z licznikiem w pętlach z opóźnieniem: przy var wszystkie wywołania widzą tę samą, końcową wartość, przy let każda iteracja dostaje własną kopię licznika i zachowuje swoją.

Przykład dla let i const (zasięg blokowy)

Przy let i const każda para klamer tworzy nowy zasięg, a temporal dead zone dotyczy właśnie tego bloku, a nie całej funkcji.

function checkEnclosures() {
  // console.log(enclosureStatus);  // ReferenceError (temporal dead zone)

  if (true) {
    let enclosureStatus = "Secure";
    console.log(enclosureStatus);  // "Secure"
  }

  // console.log(enclosureStatus);  // ReferenceError (poza zasięgiem bloku)
}

checkEnclosures();

Obie zakomentowane linie skończyłyby się błędem, ale z zupełnie różnych powodów: pierwsza dlatego, że zmienna siedzi jeszcze w temporal dead zone, druga dlatego, że blok if się skończył i zmienna przestała istnieć. Klamry są tu prawdziwym murem i dokładnie o to nam chodzi - zmienna blokowa zostaje w swojej zagrodzie. W ćwiczeniu, które czeka Cię zaraz po tej lekcji, poćwiczysz zasięg zmiennych w różnych kontekstach: stworzysz zmienne z różnym zasięgiem - globalnym, funkcyjnym i blokowym - i będziesz obserwować ich zachowanie.

Praktyczne przykłady hoistingu w Parku Jurajskim

Przykład 1: System monitorowania dinozaurów

Hoisting funkcji pozwala uporządkować plik według ważności, a nie według kolejności wykonania. Główna procedura idzie na górę, funkcje pomocnicze, z których korzysta, na sam dół - i wszystko nadal działa.

// System monitorowania dinozaurów

// Funkcje główne są zdefiniowane na górze dla przejrzystości
function initMonitoringSystem() {
  console.log("Inicjalizacja systemu monitorowania dinozaurów...");

  // Możemy wywołać te funkcje, choć są zdefiniowane później
  const healthStatus = checkDinosaurHealth("Rex");
  const locationData = trackDinosaur("Blue");

  return {
    health: healthStatus,
    location: locationData,
    systemStatus: "Online"
  };
}

// Wywołanie głównej funkcji
const systemStatus = initMonitoringSystem();
console.log(systemStatus);

// Funkcje pomocnicze zdefiniowane na dole pliku
function checkDinosaurHealth(dinoName) {
  console.log(`Sprawdzanie stanu zdrowia dinozaura: ${dinoName}`);
  return "Zdrowy";
}

function trackDinosaur(dinoName) {
  console.log(`Śledzenie dinozaura: ${dinoName}`);
  return { x: 135, y: 270, area: "Sektor B" };
}

Wywołanie initMonitoringSystem wypada w linii, do której żadna z funkcji pomocniczych jeszcze "nie doszła", a mimo to kod wykonuje się bez zgrzytu. To czysty hoisting deklaracji funkcji: obie były kompletne, zanim ruszyła pierwsza instrukcja. W czasie działania programu nic się już magicznie nie przesuwa, a zysk jest czysto ludzki - kto otworzy ten plik, najpierw przeczyta, co system robi, a dopiero potem, w jaki sposób.

Przykład 2: Pułapka hoistingu

Ten sam mechanizm potrafi zadziałać przeciwko nam. Hoisting staje się zdradliwy, gdy funkcja wewnętrzna deklaruje zmienną o nazwie, która istnieje już w zasięgu zewnętrznym. Przeczytaj kod uważnie i spróbuj przewidzieć wynik, zanim zajrzysz do wyjaśnienia.

// Pułapka związana z hoistingiem

// Funkcja sprawdzająca zabezpieczenia
function checkSecurity() {
  var fenceStatus = "Offline"; // Hoistowana na górę funkcji

  function enableFences() {
    // Lokalna zmienna jest hoistowana na górę enableFences,
    // ale aż do linii inicjalizacji nie ma żadnej wartości
    console.log("Aktualny status płotu przed zmianą:", fenceStatus); // undefined!

    // Lokalna zmienna fenceStatus przesłania tę z wyższego zakresu
    var fenceStatus = "Online";
    console.log("Nowy status płotu:", fenceStatus); // "Online"
  }

  enableFences();
  console.log("Status płotu w głównej funkcji:", fenceStatus); // "Offline" (nie zmieniono)
}

checkSecurity();

Kryje się tu subtelna pułapka: console.log wewnątrz enableFences wypisuje undefined, ponieważ lokalna zmienna fenceStatus została wyniesiona na górę funkcji wewnętrznej i od pierwszej linii przesłania tę z zasięgu zewnętrznego, choć wartość dostaje dopiero niżej. Zewnętrzna zmienna również nigdy się nie zmienia - do końca ma wartość "Offline". W prawdziwym parku wygląda to tak, że panel operatora ogłasza włączone ogrodzenia, a główna funkcja bezpieczeństwa nadal uważa je za wyłączone.

Przykład 3: Lepsze podejście z let i const

Zamiana var na let i const likwiduje całą tę klasę problemów, bo zbyt wczesny odczyt zatrzymuje program, zamiast po cichu produkować undefined.

// Lepsze podejście z użyciem let i const

function parkOperations() {
  // Używamy const dla wartości, które nie powinny się zmieniać
  const maxVisitors = 2000;

  // Używamy let dla zmiennych, które będą się zmieniać
  let currentVisitors = 0;

  function admitVisitors(count) {
    // Przy let i const odczyt zmiennej przed deklaracją kończy się błędem,
    // co znacznie ułatwia wychwycenie problemu

    // To by spowodowało błąd:
    // console.log(availableSpace);  // ReferenceError: Cannot access before initialization

    // Najpierw deklarujemy, potem używamy
    const availableSpace = maxVisitors - currentVisitors;
    if (count <= availableSpace) {
      currentVisitors += count;
      console.log(`Przyjęto ${count} odwiedzających. Aktualnie w parku: ${currentVisitors}`);
      return true;
    }

    console.log(`Za dużo odwiedzających! Dostępne miejsca: ${availableSpace}`);
    return false;
  }

  // Testujemy naszą funkcję
  admitVisitors(500);  // Przyjęto 500 odwiedzających
  admitVisitors(1000); // Przyjęto 1000 odwiedzających
  admitVisitors(700);  // Za dużo odwiedzających! Dostępne miejsca: 500

  return currentVisitors;
}

console.log(`Łączna liczba odwiedzających: ${parkOperations()}`);

Sprawdźmy, co się tu nie zmieniło: maxVisitors i currentVisitors nadal są hoistowane, bo hoistingowi podlega każda deklaracja. Zmieniła się reakcja na pomyłkę - temporal dead zone przerabia zbyt wczesny odczyt na głośny błąd zamiast na dyskretne undefined. Każda wartość powstaje dokładnie tam, gdzie jest potrzebna, i ani chwili wcześniej, dzięki czemu logikę bramek czyta się z góry na dół, bez trzymania reguł hoistingu w głowie. O to właśnie chodzi w praktyce: nie o wykucie mechanizmu, tylko o pisanie kodu, w którym ten mechanizm nigdy nie zaskakuje.

Praktyczne wskazówki dotyczące hoistingu

  1. Zawsze deklaruj zmienne na górze ich zasięgu - to minimalizuje problemy związane z hoistingiem i sprawia, że kod czyta się dużo łatwiej.

  2. Preferuj let i const zamiast var - błędy z temporal dead zone są nieporównanie łatwiejsze do zdiagnozowania niż tajemnicze wartości undefined, które ujawniają się kilkaset linii dalej.

  3. Deklaruj funkcje przed ich użyciem - hoisting funkcji działa, ale naturalna kolejność czytania i tak pozostaje najczytelniejsza dla osoby, która wróci do tego kodu za pół roku.

  4. Unikaj deklaracji funkcji wewnątrz bloków warunkowych - zachowanie potrafi się różnić między środowiskami, więc bezpieczniej użyć wtedy wyrażenia funkcyjnego przypisanego do zmiennej.

  5. Pamiętaj, że hoisting dotyczy deklaracji, a nie inicjalizacji - przypisanie wartości zachodzi dokładnie tam, gdzie je napisaliśmy, nigdy wcześniej.

Większy przykład: system zarządzania incydentami w parku

Poniżej znajdziesz pełniejszy system zarządzania incydentami w Parku Jurajskim, który zbiera w jednym miejscu wszystko z tej lekcji: hoistowane deklaracje funkcji, zmienną var na poziomie modułu oraz let i const użyte do stanu, który się zmienia, i do stanu, który zmieniać się nie może.

// System zarządzania incydentami w Parku Jurajskim

// Wykorzystanie hoistingu - deklarujemy zmienne na początku
var activeIncidents = [];
let alertLevel = "Normalny";
const MAX_INCIDENTS = 5;

// Główna funkcja do inicjalizacji systemu
function initIncidentSystem() {
  // Ta zmienna jest hoistowana tylko w obrębie tej funkcji
  var systemStatus = "Inicjalizacja";

  // Wykorzystujemy hoisting funkcji - możemy je wywołać przed definicją
  logSystemStatus();
  resetIncidents();

  systemStatus = "Online";
  logSystemStatus();

  // Funkcja lokalna - widoczna tylko wewnątrz initIncidentSystem
  function logSystemStatus() {
    console.log(`Status systemu: ${systemStatus}`);
  }

  return {
    reportIncident,      // Referencja do funkcji zdefiniowanej poniżej
    checkAlertLevel,     // Funkcja zdefiniowana poniżej
    getActiveIncidents,  // Funkcja zdefiniowana poniżej
    resetIncidents       // Funkcja zdefiniowana wewnątrz initIncidentSystem
  };

  // Funkcja lokalna, którą zwracamy jako część API
  function resetIncidents() {
    console.log("Resetowanie listy incydentów...");
    activeIncidents = [];
    updateAlertLevel();
  }
}

// Deklaracje funkcji są hoistowane, więc można je wywołać przed definicją
// Funkcja do zgłaszania nowego incydentu
function reportIncident(location, type, severity) {
  console.log(`Zgłoszenie incydentu: ${type} w lokalizacji ${location} (poziom zagrożenia: ${severity})`);

  const incident = {
    id: generateIncidentId(),
    location,
    type,
    severity,
    timestamp: new Date().toISOString(),
    status: "Aktywny"
  };

  activeIncidents.push(incident);

  if (activeIncidents.length > MAX_INCIDENTS) {
    declareEmergency();
  } else {
    updateAlertLevel();
  }

  return incident;
}

// Generowanie unikalnego ID incydentu
function generateIncidentId() {
  return `INC-${Date.now()}-${Math.floor(Math.random() * 1000)}`;
}

// Aktualizacja poziomu alertu na podstawie aktywnych incydentów
function updateAlertLevel() {
  const highSeverityCount = activeIncidents.filter(inc => inc.severity === "Wysoki").length;

  if (highSeverityCount >= 3) {
    alertLevel = "Krytyczny";
  } else if (highSeverityCount > 0 || activeIncidents.length >= 3) {
    alertLevel = "Podwyższony";
  } else if (activeIncidents.length > 0) {
    alertLevel = "Ostrożność";
  } else {
    alertLevel = "Normalny";
  }

  console.log(`Poziom alertu zaktualizowany: ${alertLevel}`);
}

// Funkcja wywoływana w przypadku zbyt wielu incydentów
function declareEmergency() {
  alertLevel = "Ewakuacja";
  console.log("UWAGA! Zbyt wiele aktywnych incydentów. Ogłaszamy ewakuację parku!");
  // Kod do inicjacji protokołów ewakuacji...
}

// Funkcja do sprawdzania aktualnego poziomu alertu
function checkAlertLevel() {
  return {
    level: alertLevel,
    incidentCount: activeIncidents.length,
    timestamp: new Date().toISOString()
  };
}

// Funkcja zwracająca listę aktywnych incydentów
function getActiveIncidents() {
  return [...activeIncidents]; // Zwracamy kopię, aby nikt nie zmodyfikował oryginału
}

// Inicjalizacja systemu
const incidentSystem = initIncidentSystem();

// Testowanie systemu
console.log("===== TESTOWANIE SYSTEMU ZARZĄDZANIA INCYDENTAMI =====");

// Sprawdzanie początkowego stanu
console.log("Początkowy poziom alertu:", incidentSystem.checkAlertLevel().level);

// Zgłaszanie incydentów
incidentSystem.reportIncident("Zagroda T-Rex", "Uszkodzenie ogrodzenia", "Wysoki");
incidentSystem.reportIncident("Centrum Gości", "Brak zasilania", "Średni");

// Sprawdzanie stanu po zgłoszeniach
console.log("Aktywne incydenty:", incidentSystem.getActiveIncidents().length);
console.log("Aktualny poziom alertu:", incidentSystem.checkAlertLevel().level);

// Dodawanie kolejnych incydentów wysokiego priorytetu
incidentSystem.reportIncident("Laboratorium", "Wyciek materiału genetycznego", "Wysoki");
incidentSystem.reportIncident("Zagroda Velociraptorów", "Próba ucieczki", "Wysoki");

// Powinno wywołać stan ewakuacji
incidentSystem.reportIncident("Sektor B", "Dinozaur poza zagrodą", "Wysoki");
incidentSystem.reportIncident("Centrum Operacyjne", "Awaria systemów bezpieczeństwa", "Wysoki");

// Reset systemu
incidentSystem.resetIncidents();
console.log("Po resecie - poziom alertu:", incidentSystem.checkAlertLevel().level);

Prześledź kolejność zdarzeń w tym pliku. initIncidentSystem wywołuje logSystemStatus i resetIncidents, zanim którakolwiek z nich pojawi się w kodzie, a resetIncidents stoi nawet za instrukcją return - mimo to wszystko działa, bo deklaracje funkcji są kompletne przed wykonaniem pierwszej linii ciała. Ze zmiennymi jest inaczej: var systemStatus można odczytać od samego początku funkcji, ale wartość "Inicjalizacja" dostaje dopiero w swojej linii, a activeIncidents, alertLevel i MAX_INCIDENTS celowo trafiły na samą górę pliku, żeby nikt nie sięgnął po nie za wcześnie.

Podsumowanie

Hoisting to ważny koncept JavaScriptu, który kształtuje sposób wykonywania naszego kodu:

  1. Deklaracje funkcji są hoistowane w całości - można ich używać przed deklaracją.

  2. Zmienne var są hoistowane i inicjalizowane wartością undefined - można się do nich odwołać wcześniej, ale do momentu przypisania nie niosą żadnej użytecznej wartości.

  3. Zmienne let i const (a razem z nimi klasy) są hoistowane, ale zostają w temporal dead zone - próba odczytu przed deklaracją kończy się błędem.

  4. Wyrażenia funkcyjne, w tym funkcje strzałkowe, podlegają regułom zmiennych - zmienna jest hoistowana, przypisana funkcja już nie.

Zrozumienie hoistingu jest kluczowe dla pisania przewidywalnego kodu JavaScript. Działa to dokładnie jak w samym Parku Jurajskim - znajomość zasad i protokołów wystarcza, żeby dzień minął bez niespodzianek i niebezpiecznych sytuacji.

"Hoisting w JavaScripcie przypomina poranne rozruchy parku" - mówi Dr. Rex. "Zanim przyjadą zwiedzający, zanim ruszy kod, część przygotowań dzieje się sama: protokoły są gotowe, procedury na miejscu. Ale prawdziwe dane trzeba dopiero zebrać na bieżąco, a sięganie po nie za wcześnie nie powie ci absolutnie nic!"

W jednej z następnych lekcji weźmiemy na warsztat słowo kluczowe this - kolejny fundamentalny, a przy tym potrafiący nieźle namieszać element JavaScriptu.

Kod do tej lekcji: index.js
// Hoisting w JavaScript - Park Jurajski
console.log("Laboratorium Hoisting");
console.log("Zrozumienie wynoszenia w JavaScript\n");

// ===========================================
// 1. CZYM JEST HOISTING?
// ===========================================
console.log("=== 1. Wprowadzenie do hoisting ===");

// JavaScript "wynosi" deklaracje na górę zasięgu
// Możemy używać funkcji przed jej deklaracją!

roarDinosaur("T-Rex"); // Działa!

function roarDinosaur(name) {
  console.log(`${name} says: ROAAARRR!`);
}

roarDinosaur("Velociraptor");

console.log("\nFunkcja działa przed deklaracją dzięki hoisting!");

// ===========================================
// 2. HOISTING FUNKCJI
// ===========================================
console.log("\n=== 2. Hoisting funkcji ===");

// Deklaracje funkcji są hoistowane
feedDinosaur("Triceratops"); // Działa

function feedDinosaur(dino) {
  console.log(`Karmienie: ${dino}`);
}

// Wyrażenia funkcyjne NIE są hoistowane
// feedDino2("Stegosaurus"); // ERROR!

const feedDino2 = function(dino) {
  console.log(`Karmienie: ${dino}`);
};

feedDino2("Stegosaurus"); // Teraz działa

// Arrow functions też NIE są hoistowane
// feedDino3("Brachiosaurus"); // ERROR!

const feedDino3 = (dino) => {
  console.log(`Karmienie: ${dino}`);
};

feedDino3("Brachiosaurus"); // Teraz działa

// ===========================================
// 3. HOISTING VAR
// ===========================================
console.log("\n=== 3. Hoisting zmiennych var ===");

console.log("\nPrzed deklaracją:");
console.log("dinoName:", typeof dinoName); // undefined (nie error!)

var dinoName = "T-Rex";

console.log("Po deklaracji:");
console.log("dinoName:", dinoName); // T-Rex

// Tak naprawdę JavaScript interpretuje to jako:
// var dinoName; // Deklaracja wyniesiona na górę
// console.log(dinoName); // undefined
// dinoName = "T-Rex"; // Przypisanie

// ===========================================
// 4. HOISTING LET I CONST
// ===========================================
console.log("\n=== 4. Hoisting let i const ===");

// let i const też są hoistowane, ale...
// znajdują się w "Temporal Dead Zone" (TDZ)

console.log("\nPróba użycia przed deklaracją:");

// console.log(dinoSpecies); // ReferenceError: Cannot access before initialization
// console.log(parkName); // ReferenceError: Cannot access before initialization

let dinoSpecies = "Velociraptor";
const parkName = "Jurassic Park";

console.log("Po deklaracji:");
console.log("dinoSpecies:", dinoSpecies);
console.log("parkName:", parkName);

// ===========================================
// 5. TEMPORAL DEAD ZONE (TDZ)
// ===========================================
console.log("\n=== 5. Temporal Dead Zone (TDZ) ===");

function demonstrateTDZ() {
  console.log("\nWewnątrz funkcji - przed deklaracją:");

  // Ta strefa to TDZ dla 'dinosaur'
  // console.log(dinosaur); // ERROR w TDZ

  let dinosaur = "Triceratops";

  console.log("Po deklaracji:", dinosaur); // Działa
}

demonstrateTDZ();

// ===========================================
// 6. RÓŻNICE: var vs let vs const
// ===========================================
console.log("\n=== 6. Porównanie: var vs let vs const ===");

function compareHoisting() {
  console.log("\nTest hoisting:");

  // var - hoistowany z wartością undefined
  console.log("var dinosaur1:", typeof dinosaur1); // undefined
  var dinosaur1 = "T-Rex";
  console.log("var dinosaur1:", dinosaur1); // T-Rex

  // let - hoistowany, ale w TDZ
  // console.log("let dinosaur2:", dinosaur2); // ERROR: TDZ
  let dinosaur2 = "Velociraptor";
  console.log("let dinosaur2:", dinosaur2); // Velociraptor

  // const - hoistowany, ale w TDZ
  // console.log("const dinosaur3:", dinosaur3); // ERROR: TDZ
  const dinosaur3 = "Triceratops";
  console.log("const dinosaur3:", dinosaur3); // Triceratops
}

compareHoisting();

// ===========================================
// 7. HOISTING W BLOKACH
// ===========================================
console.log("\n=== 7. Hoisting w blokach ===");

function blockHoisting() {
  console.log("\nPrzed blokiem:");
  console.log("globalVar:", typeof globalVar); // undefined
  // console.log("blockLet:", typeof blockLet); // ERROR

  var globalVar = "Dostępny wszędzie";

  if (true) {
    console.log("\nW bloku:");
    let blockLet = "Tylko w bloku";
    const blockConst = "Tylko w bloku (const)";

    console.log("blockLet:", blockLet);
    console.log("blockConst:", blockConst);
    console.log("globalVar:", globalVar);
  }

  console.log("\nPo bloku:");
  console.log("globalVar:", globalVar); // Działa
  // console.log("blockLet:", blockLet); // ERROR
  // console.log("blockConst:", blockConst); // ERROR
}

blockHoisting();

// ===========================================
// 8. HOISTING W PĘTLACH
// ===========================================
console.log("\n=== 8. Hoisting w pętlach ===");

console.log("\nPętla z var:");
for (var i = 0; i < 3; i++) {
  console.log(`  Iteracja ${i + 1}`);
}
console.log("Po pętli - i:", i); // Działa (i = 3)

console.log("\nPętla z let:");
for (let j = 0; j < 3; j++) {
  console.log(`  Iteracja ${j + 1}`);
}
// console.log("Po pętli - j:", j); // ERROR: j is not defined

// ===========================================
// 9. PRAKTYCZNE PROBLEMY Z HOISTING
// ===========================================
console.log("\n=== 9. Typowe pułapki ===");

// Problem 1: Nadpisywanie funkcji
function problemExample1() {
  console.log("\nProblem 1: Nadpisywanie");

  function greet() {
    console.log("  Pierwsze powitanie");
  }

  greet(); // Która funkcja zostanie wywołana?

  function greet() {
    console.log("  Drugie powitanie (to zostanie użyte!)");
  }

  // JavaScript "wynosi" obie deklaracje,
  // ale druga nadpisuje pierwszą
}

problemExample1();

// Problem 2: var w pętli z setTimeout
console.log("\nProblem 2: var w pętli z setTimeout");

console.log("Z var (wszystkie pokażą 3):");
for (var k = 0; k < 3; k++) {
  setTimeout(function() {
    console.log(`  var k = ${k}`);
  }, 100);
}

setTimeout(() => {
  console.log("\nZ let (pokażą 0, 1, 2):");
  for (let m = 0; m < 3; m++) {
    setTimeout(function() {
      console.log(`  let m = ${m}`);
    }, 100);
  }
}, 200);

// ===========================================
// 10. BEST PRACTICES
// ===========================================
console.log("\n=== 10. Best practices ===");

// DOBRE PRAKTYKI:

// 1. Deklaruj zmienne na początku zasięgu
function goodPractice1() {
  const parkName = "Jurassic Park";
  let dinosaurCount = 0;
  let totalVisitors = 0;

  dinosaurCount = 15;
  totalVisitors = 1000;

  console.log(`\n${parkName}: ${dinosaurCount} dinozaurów, ${totalVisitors} gości`);
}

goodPractice1();

// 2. Używaj const domyślnie, let gdy potrzeba
const SECURITY_LEVEL = "HIGH";
let currentStatus = "OPERATIONAL";

console.log(`Zabezpieczenia: ${SECURITY_LEVEL}`);
console.log(`Status: ${currentStatus}`);

// 3. Unikaj var
// var oldWay = "Nie używaj tego!"; // ZŁE

// 4. Deklaruj funkcje przed użyciem (czytelność)
function wellOrganized() {
  // Deklaracje na początku
  const MAX_CAPACITY = 50;
  let currentCapacity = 0;

  // Funkcje pomocnicze
  function addDinosaur(name) {
    if (currentCapacity < MAX_CAPACITY) {
      currentCapacity++;
      console.log(`  Dodano ${name}. Pojemność: ${currentCapacity}/${MAX_CAPACITY}`);
    } else {
      console.log(`  Brak miejsca dla ${name}`);
    }
  }

  // Główna logika
  console.log("\nSystem zarządzania pojemnością:");
  addDinosaur("T-Rex");
  addDinosaur("Velociraptor");
  addDinosaur("Triceratops");
}

wellOrganized();

// ===========================================
// 11. PRZYKŁAD KOMPLEKSOWY
// ===========================================
console.log("\n=== 11. System monitoringu - przykład kompleksowy ===");

function createMonitoringSystem() {
  // Deklaracje na początku (best practice)
  const systemName = "Dino Monitor v1.0";
  let isActive = false;
  let alertCount = 0;

  // Funkcje pomocnicze
  function activate() {
    isActive = true;
    console.log(`\n${systemName} aktywowany`);
  }

  function deactivate() {
    isActive = false;
    console.log(`${systemName} dezaktywowany`);
  }

  function sendAlert(message) {
    if (isActive) {
      alertCount++;
      console.log(`Alert #${alertCount}: ${message}`);
    } else {
      console.log("System nieaktywny - alert pominięty");
    }
  }

  function getStats() {
    console.log(`\nStatystyki ${systemName}:`);
    console.log(`   Status: ${isActive ? "Aktywny" : "Nieaktywny"}`);
    console.log(`   Wysłane alerty: ${alertCount}`);
  }

  // Główny interfejs
  return {
    start: activate,
    stop: deactivate,
    alert: sendAlert,
    stats: getStats
  };
}

const monitor = createMonitoringSystem();

monitor.alert("Test przed aktywacją"); // Pominięty
monitor.start();
monitor.alert("T-Rex zbliża się do ogrodzenia");
monitor.alert("Poziom zabezpieczeń krytyczny");
monitor.stats();
monitor.stop();
monitor.alert("Test po dezaktywacji"); // Pominięty
monitor.stats();

console.log("\nGratulacje! Opanowałeś hoisting w JavaScript!");

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Zadania praktyczne w grze

  • Edytor kodu

    Zadeklaruj globalną stałą parkName = 'Jurassic Park'. Napisz funkcję checkEnclosure(), która tworzy lokalną stałą enclosureName = 'Zone A', a w bloku if (true) tworzy przez let zmienną alarmLevel = 5 i wyświetla w konsoli parkName, enclosureName i alarmLevel. Funkcja zwraca enclosureName. Wywołaj checkEnclosure(). Poza funkcją zmiennych enclosureName i alarmLevel ma nie być.

  1. Zadanie z kodemĆwiczenie: Zakres zmiennych

Przydatne artykuły