var w JavaScript - zasięg, hoisting i pułapki w praktyce

25 października 2026

Grafika z napisem "HOISTING" i logo "JS" na ciemnym tle z fioletowym gradientem.

Otwierasz starszy plik JavaScript, widzisz var w środku instrukcji if i zakładasz, że zmienna zniknie po zamknięciu klamry. Tak zwykle nie jest, bo var działa przede wszystkim w zakresie funkcji, choć przy hoistingu i skryptach globalnych potrafi zachować się jeszcze szerzej, niż sugeruje zapis kodu.

Najkrócej: var jest starszym sposobem deklarowania zmiennych

  • Zakres funkcji: var ignoruje większość bloków if, for i try.
  • Hoisting: deklaracja trafia logicznie na początek zakresu, ale wartość pojawia się dopiero przy przypisaniu.
  • Nowy kod: zwykle wybieraj const, a gdy wartość ma się zmieniać, let.
  • Pułapka: pętla z var może sprawić, że wszystkie funkcje odczytają ten sam, końcowy indeks.
  • Frameworki: React, Vue czy Svelte nie zmieniają zasad działania zakresów JavaScript.

Tabela porównująca zasięg i możliwość reasynacji słów kluczowych `const`, `let` i `var` w JavaScript.

var obejmuje funkcję, a nie blok kodu

Wyobraź sobie zmienną utworzoną wewnątrz if. Przy let lub const jej zakres kończy się na klamrze. Przy var klamra nie tworzy osobnego zakresu, więc zmienna pozostaje dostępna dalej.

if (true) {
  var message = "Gotowe";
}

console.log(message); // "Gotowe"

Jeśli ten sam zapis znajdzie się wewnątrz funkcji, zmienna będzie dostępna w całej funkcji, lecz nie poza nią.

function buildLabel() {
  var label = "Koszyk";
  console.log(label); // "Koszyk"
}

console.log(label); // ReferenceError

W aktualnej specyfikacji ECMAScript 2026 deklaracja var jest powiązana z tak zwanym VariableEnvironment, czyli środowiskiem wykonania funkcji lub skryptu. W praktyce oznacza to prostą zasadę: funkcja tworzy granicę dla var, zwykły blok zazwyczaj nie.

Istnieje jeszcze różnica między klasycznym skryptem a modułem ES. Top-level var w klasycznym skrypcie przeglądarkowym może stać się właściwością globalnego obiektu, natomiast w module pozostaje związany z modułem. To jeden z powodów, dla których stary kod dołączany przez wiele tagów łatwiej przypadkowo zderza nazwy.

Hoisting tworzy nazwę wcześniej, ale nie przenosi wartości

Największe nieporozumienie wokół var bierze się z hoistingu. Mechanizm ten sprawia, że deklaracja zmiennej jest przygotowywana przed wykonaniem kodu w danym zakresie, ale inicjalizacja nie odbywa się wcześniej.

console.log(status); // undefined

var status = "ready";

Silnik JavaScript traktuje ten fragment podobnie do poniższego zapisu:

var status;

console.log(status); // undefined

status = "ready";

To nie jest to samo co użycie niezadeklarowanej zmiennej. Nazwa status już istnieje, lecz przez chwilę przechowuje undefined. Dokumentacja MDN dotycząca instrukcji var pokazuje ten mechanizm także przy deklaracji umieszczonej na końcu funkcji.

Przy let i const podobny kod kończy się błędem ReferenceError, ponieważ zmienna znajduje się w tak zwanej temporal dead zone. To obszar od początku zakresu do miejsca deklaracji, w którym nazwa istnieje technicznie, ale nie wolno jej jeszcze odczytać.

Wniosek jest praktyczny: jeśli widzisz odczyt zmiennej przed jej deklaracją, nie zakładaj, że kod jest dobrze zaprojektowany tylko dlatego, że działa. Hoisting może ukryć błąd kolejności, który stanie się trudny do znalezienia po rozbudowie funkcji.

W nowym kodzie wybierz const, let albo var według jednego pytania

Prawdę mówiąc, decyzję da się uprościć do pytania: czy przypisanie do tej nazwy będzie później zmieniane? Jeśli nie, użyj const. Jeśli tak, wybierz let. var zostaw głównie dla kodu starszego, kompatybilności ze starym stylem albo świadomego wykorzystania zakresu funkcji.

Słowo Kiedy użyć Najważniejsze ograniczenie
const Gdy sama zmienna nie dostanie nowej wartości Nie można ponownie przypisać wartości do tej samej nazwy
let Gdy wartość będzie się zmieniać, na przykład licznik w pętli Obowiązuje zakres bloku i nie wolno deklarować tej samej nazwy ponownie w tym samym zakresie
var Przy utrzymaniu starszego kodu lub celowym wykorzystaniu zakresu funkcji Brak zakresu blokowego, hoisting i możliwość ponownej deklaracji

Uważam, że w nowym kodzie aplikacji wybór powinien zaczynać się od const, a nie od var. Reguła no-var w ESLint formalizuje właśnie takie podejście i może automatycznie wskazywać miejsca, w których starszą deklarację da się zastąpić przez let lub const.

Nie oznacza to, że var jest nieważnym albo usuniętym elementem języka. Nadal działa w aktualnym JavaScript, lecz jego elastyczność często utrudnia czytanie kodu. Gdy var pojawia się w projekcie, pytanie brzmi raczej: czy ta szerokość zakresu jest potrzebna, czy tylko odziedziczona?

Pętla z var może podpiąć wszystkie przyciski do ostatniego indeksu

Najłatwiej zobaczyć problem na przykładzie interfejsu. Załóżmy, że tworzysz trzy przyciski i do każdego podpinasz funkcję, która ma wypisać jego numer.

for (var i = 0; i < 3; i++) {
  setTimeout(function () {
    console.log(i);
  }, 0);
}

// Wynik:
// 3
// 3
// 3

Wszystkie funkcje korzystają z tej samej zmiennej i. Kiedy asynchroniczne wywołania zostają wykonane, pętla zdążyła już zakończyć pracę, więc i ma wartość 3. Przy let każda iteracja otrzymuje własne powiązanie:

for (let i = 0; i < 3; i++) {
  setTimeout(function () {
    console.log(i);
  }, 0);
}

// Wynik:
// 0
// 1
// 2

Ten sam problem pojawia się przy obsłudze kliknięć, menu, kart produktów i list renderowanych w aplikacji. W kodzie interfejsu użytkownik klika pierwszy element, ale handler odczytuje numer ostatniego. Taki błąd wygląda jak problem z DOM-em albo frameworkiem, choć źródło tkwi w zakresie zmiennej.

Sytuacja Prawdopodobna przyczyna Co zrobić
Zmienna z if działa po zamknięciu bloku var nie tworzy zakresu blokowego Zamień deklarację na const albo let
Odczyt przed deklaracją zwraca undefined Hoisting deklaracji bez wcześniejszej inicjalizacji Przenieś deklarację i przypisanie przed pierwsze użycie
Wszystkie callbacki pokazują ostatni indeks Funkcje współdzielą jedną zmienną var Użyj let w pętli albo przekaż indeks jako argument
Druga deklaracja tej samej nazwy nie zgłasza błędu var dopuszcza ponowną deklarację w tym samym zakresie Włącz linting i sprawdź, czy nazwa nie została przypadkowo nadpisana

W frameworkach var najczęściej zdradza starszy kod

React, Vue, Svelte i inne narzędzia nie zmieniają reguł JavaScript. Kod komponentu nadal podlega zakresom funkcji, bloków, modułów i zamknięć. Jeśli var trafi do funkcji obsługującej stan, zdarzenie albo renderowanie listy, jego zachowanie pozostanie takie samo jak w zwykłym pliku .js.

W kodzie źródłowym komponentu najczęściej lepiej użyć const lub let. Wygodniej wtedy odczytać, które dane mają stałe przypisanie, które są modyfikowane i gdzie kończy się ich zakres. To pomaga ograniczyć przypadkowe nadpisania, szczególnie gdy komponent zaczyna obsługiwać kilka zdarzeń naraz.

Inaczej wygląda sytuacja, gdy var znajduje się w wygenerowanym pliku produkcyjnym. Bundler albo starszy etap transpilacji może przekształcić kod wejściowy do innej postaci, więc ręczna zmiana takiego pliku zwykle zostanie utracona przy kolejnym buildzie. Wtedy szukaj problemu w pliku źródłowym i korzystaj z map źródeł, zamiast poprawiać gotowy bundle.

Przy migracji starego projektu nie zamieniaj wszystkich deklaracji mechanicznie. Zmiana var na let może zmienić wynik pętli, dostępność zmiennej poza blokiem albo moment zgłaszania błędu. Najpierw sprawdź, czy kod korzysta z hoistingu, ponownej deklaracji lub wspólnej zmiennej w callbackach.

Jedna zasada porządkuje większość decyzji

Gdy zmienna ma pozostać w jednym bloku i nie dostanie nowej wartości, wybierz const. Gdy wartość będzie się zmieniać, ale nadal ma być ograniczona do bloku, wybierz let. Po var sięgaj wtedy, gdy utrzymujesz starszy kod albo świadomie potrzebujesz zakresu funkcji.

Najprostsza odpowiedź na pytanie, czym jest var, brzmi więc: to działająca, starsza deklaracja zmiennej z zakresem funkcji i hoistingiem. Gdy zapamiętasz te dwa zachowania, łatwiej przewidzisz wynik kodu, szybciej znajdziesz błąd w callbacku i bezpieczniej ocenisz fragment odziedziczony po dawnym projekcie.

FAQ - Najczęstsze pytania

var ma przede wszystkim zakres funkcji, a zwykły blok utworzony przez if, for lub try nie tworzy dla niej osobnego zakresu. Dlatego zmienna pozostaje dostępna po zamknięciu klamry. W funkcji będzie widoczna w całej funkcji, ale nie poza nią; let i const ograniczają ją do bloku.

Podczas przygotowania zakresu deklaracja var jest traktowana tak, jakby znalazła się na jego początku, ale przypisanie wartości nadal następuje dopiero w miejscu wykonania kodu. Dlatego odczyt przed przypisaniem zwraca undefined, a nie powoduje błędu. Przy let i const odczyt przed deklaracją kończy się błędem ReferenceError z powodu temporal dead zone.

W pętli z var wszystkie funkcje korzystają z tego samego powiązania zmiennej i. Gdy asynchroniczne callbacki z setTimeout zostaną wykonane, pętla zakończyła już pracę, więc przy trzech iteracjach każdy callback odczytuje wartość 3. Użycie let tworzy osobne powiązanie dla każdej iteracji, a alternatywnie można przekazać indeks jako argument.

Użyj const, gdy nazwa nie dostanie później nowej wartości, a let, gdy przypisanie będzie się zmieniać. var warto zostawić głównie w starszym kodzie, dla kompatybilności albo wtedy, gdy świadomie potrzebujesz zakresu funkcji. Przy migracji nie zamieniaj deklaracji mechanicznie, ponieważ może to zmienić dostępność zmiennej, działanie pętli lub moment zgłoszenia błędu.
Oceń artykuł

Średnia: 0.0 / 5 · 0 ocen

Tagi

var hoisting zakres callbacki moduły

Udostępnij artykuł

Komentarze (0)
Dodaj komentarz