Kurs JavaScript i TypeScript · Moduł 1: Podstawy JavaScript

Deklaracja zmiennych (var, let, const)

9 min czytania ·
W tej lekcji7

W Parku Jurajskim różne gatunki dinozaurów wymagają różnych poziomów zabezpieczeń - łagodny Brachiosaurus może przebywać w otwartym wybiegu, podczas gdy agresywny Velociraptor potrzebuje wzmocnionego, zamkniętego pomieszczenia. Podobnie w JavaScript mamy trzy różne sposoby deklarowania zmiennych: var, let i const, z których każdy oferuje inny poziom "zabezpieczeń" i elastyczności.

Podstawy deklaracji zmiennych

Zmienne w JavaScript to jak oznaczone zagrody w Parku Jurajskim - pozwalają na przechowywanie i organizację danych, do których możemy później się odwoływać. Zanim będziemy mogli użyć zmiennej, musimy ją zadeklarować.

// Deklaracja zmiennej dinosaur przy użyciu słowa kluczowego var
var dinosaur = "T-Rex";

// Deklaracja zmiennej height przy użyciu słowa kluczowego let
let height = 5.6;

// Deklaracja stałej MAX_SPEED przy użyciu słowa kluczowego const
const MAX_SPEED = 27;

Różnice między var, let i const

Zakres (scope) zmiennych

1. var - Zakres funkcyjny

Zmienne zadeklarowane za pomocą var mają zakres funkcyjny, co oznacza, że są widoczne w całej funkcji, w której zostały zadeklarowane.

function monitorDinosaurs() {
    var count = 5;

    if (count > 3) {
        var status = "Przekroczono limit bezpieczeństwa!";
        console.log(status);  // "Przekroczono limit bezpieczeństwa!"
    }

    console.log(status);  // "Przekroczono limit bezpieczeństwa!" - zmienna jest dostępna poza blokiem if
}

// console.log(count);  // Błąd! 'count' nie jest zdefiniowane - var ma zakres funkcyjny

To jak system bezpieczeństwa, gdzie alarm uruchomiony w jednej części parku (wewnątrz bloku if) nadal jest słyszalny w całym centrum kontroli (funkcja monitorDinosaurs), ale nie poza parkiem.

2. let - Zakres blokowy

Zmienne zadeklarowane za pomocą let mają zakres blokowy - są widoczne tylko wewnątrz bloku, w którym zostały zadeklarowane.

function securityCheck() {
    let safetyStatus = "Normalny";

    if (emergencyDetected) {
        let alarmLevel = "Czerwony";
        console.log(alarmLevel);  // "Czerwony"
    }

    // console.log(alarmLevel);  // Błąd! 'alarmLevel' nie jest zdefiniowane - zmienna dostępna tylko w bloku if
}

To jak komunikacja przez radio z ograniczonym zasięgiem - informacja o alarmie (zmienna alarmLevel) jest dostępna tylko w strefie zagrożenia (blok if), a nie w całym centrum dowodzenia.

3. const - Niezmienna wartość

const podobnie jak let ma zakres blokowy, ale dodatkowo wprowadza ograniczenie: raz przypisana wartość nie może być zmieniona.

function setupEnclosure() {
    const ENCLOSURE_ID = "A-7";
    const MAX_CAPACITY = 3;

    // ENCLOSURE_ID = "B-3";  // Błąd! Nie można zmienić wartości stałej

    let currentDinosaurs = 2;
    currentDinosaurs = 3;  // OK - zmienne let mogą zmieniać wartość
}

To jak identyfikatory zagród w parku - raz przypisany numer zagrody (np. "A-7") nie może być zmieniony, aby uniknąć pomyłek i niebezpieczeństwa.

Hoisting (wynoszenie)

W JavaScript deklaracje zmiennych i funkcji są "wynoszone" (hoisted) na górę ich zakresu. To jak przygotowywanie wszystkich zagród w parku przed przywiezieniem dinozaurów.

1. var - pełny hoisting

Zmienne zadeklarowane za pomocą var są wynoszone wraz z ich deklaracją, ale bez inicjalizacji:

console.log(dinosaurCount);  // undefined - deklaracja jest hoistowana, ale nie inicjalizacja
var dinosaurCount = 10;

Jest to równoważne:

var dinosaurCount;  // Deklaracja jest wyniesiona na górę
console.log(dinosaurCount);  // undefined
dinosaurCount = 10;  // Inicjalizacja pozostaje w oryginalnym miejscu

2. let i const - częściowy hoisting

Zmienne zadeklarowane za pomocą let i const również są wynoszone, ale nie są inicjalizowane - próba dostępu do nich przed deklaracją powoduje błąd:

// console.log(dinoSpecies);  // Błąd: Cannot access 'dinoSpecies' before initialization
let dinoSpecies = "Velociraptor";

// console.log(MAX_WEIGHT);   // Błąd: Cannot access 'MAX_WEIGHT' before initialization
const MAX_WEIGHT = 8000;

To jak procedura zabezpieczania - zagrody są przygotowane (hoisting), ale nikt nie może do nich wejść (użyć zmiennej), dopóki nie zostaną oficjalnie otwarte (zadeklarowane).

Redeclaration - ponowna deklaracja

1. var - pozwala na ponowną deklarację

var securityLevel = "Niski";
var securityLevel = "Wysoki";  // Dozwolone - nadpisuje poprzednią deklarację

To jak przeprowadzanie dinozaura z jednej zagrody do drugiej bez żadnych ograniczeń.

2. let i const - nie pozwalają na ponowną deklarację w tym samym zakresie

let carnivoreCount = 5;
// let carnivoreCount = 7;  // Błąd! 'carnivoreCount' zostało już zadeklarowane

const MAX_VISITORS = 150;
// const MAX_VISITORS = 200;  // Błąd! 'MAX_VISITORS' zostało już zadeklarowane

To jak ścisła kontrola translokacji dinozaurów - nie można przypisać tego samego gatunku do dwóch różnych zagród jednocześnie.

Kiedy używać var, let i const

Kiedy używać const

const to najbezpieczniejsza opcja - używaj jej zawsze, gdy wartość zmiennej nie będzie się zmieniać. To jak metalowe ogrodzenia dla drapieżników:

const PARK_NAME = "Jurassic Park";
const ADMIN_PASSWORD = "clevergirl123";
const DANGEROUS_SPECIES = ["T-Rex", "Velociraptor", "Dilophosaurus"];

Nawet dla obiektów i tablic, których zawartość może się zmieniać, ale referencja pozostaje stała:

const parkStatus = {
    isOpen: true,
    visitorCount: 372
};

// Dozwolone - zmieniamy właściwość obiektu, nie samą referencję
parkStatus.visitorCount = 373;

// Błąd! Nie można przypisać nowego obiektu do stałej
// parkStatus = { isOpen: false, visitorCount: 0 };

Kiedy używać let

let to dobry wybór dla zmiennych, których wartość będzie się zmieniać, ale chcemy ograniczyć ich zakres do bieżącego bloku. To jak elastyczne zagrody dla łagodniejszych dinozaurów:

function monitorParkSectors() {
    for (let i = 0; i < sectors.length; i++) {
        let currentSector = sectors[i];
        let dangerLevel = assessDanger(currentSector);

        if (dangerLevel > 7) {
            let emergencyProtocol = selectProtocol(dangerLevel);
            activateAlarm(currentSector, emergencyProtocol);
        }
    }
    // Zmienna i, currentSector, dangerLevel, emergencyProtocol nie są już dostępne tutaj
}

Kiedy używać var

Z powodu potencjalnych problemów, var jest obecnie rzadko zalecane w nowoczesnym JavaScript. Jednak może być przydatne w specyficznych sytuacjach, gdzie potrzebujemy zmienną z zakresem funkcyjnym.

function legacyCode() {
    if (condition) {
        var oldSystemVariable = "wartość";
    }

    // Dostęp do zmiennej poza blokiem, gdzie została zadeklarowana
    console.log(oldSystemVariable);
}

To jak stare, mniej bezpieczne zagrody w parku - działają, ale lepiej zastąpić je nowocześniejszymi rozwiązaniami.

Najlepsze praktyki

1. Używaj przede wszystkim const

Zawsze zaczynaj od const dla swoich zmiennych. Jeśli później okaże się, że potrzebujesz zmienić wartość, zamień na let. To jak zasada w Parku Jurajskim - najpierw zastosuj najsilniejsze zabezpieczenia, a dopiero jeśli okaże się, że potrzebujesz więcej elastyczności, rozważ mniej restrykcyjne opcje.

// Zacznij od const
const dinoData = fetchDinosaurData();

// Jeśli potrzebujesz modyfikować wartość, użyj let
let dangerLevel = 0;
for (const dino of dinoData) {
    if (dino.aggressive) {
        dangerLevel++;
    }
}

2. Unikaj var w nowym kodzie

W nowoczesnym JavaScript (ES6+) zazwyczaj lepiej jest używać let i const zamiast var.

3. Deklaruj zmienne na początku ich zakresu

To pomaga w zrozumieniu, jakie zmienne są używane w danym bloku kodu:

function processEnclosure(enclosureId) {
    // Wszystkie deklaracje na początku
    const enclosure = getEnclosure(enclosureId);
    let dinosaurCount = enclosure.inhabitants.length;
    let feedingRequired = false;

    // Logika funkcji poniżej
    if (timeElapsed > 4) {
        feedingRequired = true;
    }

    //
}

4. Używaj znaczących nazw zmiennych

Podobnie jak w parku każde pomieszczenie czy procedura ma jasne oznaczenie, tak w kodzie zmienne powinny mieć znaczące nazwy:

// ŹLE
const x = 5;
let y = getZ();

// DOBRZE
const maxDinosaursPerEnclosure = 5;
let currentSafetyRating = calculateSafetyScore();

Deklaracje zmiennych w TypeScript

TypeScript rozszerza JavaScript o statyczne typowanie, co daje dodatkową warstwę bezpieczeństwa - jak jeszcze solidniejsze ogrodzenia w parku:

// Definiowanie typów dla lepszego bezpieczeństwa
let dinoName: string = "Velociraptor";
const maxSpeed: number = 45;
const isDangerous: boolean = true;

// Definiowanie typów złożonych
interface Dinosaur {
    name: string;
    species: string;
    height: number;
    weight: number;
    dangerous: boolean;
}

const trex: Dinosaur = {
    name: "Rexy",
    species: "Tyrannosaurus Rex",
    height: 5.6,
    weight: 8000,
    dangerous: true
};

Typy w TypeScript działają jak dodatkowe protokoły bezpieczeństwa - zapobiegają umieszczeniu "roślinożercy w zagrodzie mięsożerców" (przypisaniu wartości niewłaściwego typu).

Przykład praktyczny: System monitoringu Parku Jurajskiego

Poniższy przykład ilustruje prawidłowe użycie var, let i const w bardziej rozbudowanym scenariuszu:

// Stałe wartości konfiguracyjne - nie zmieniają się
const PARK_NAME = "Jurassic Park";
const DANGER_LEVELS = {
    LOW: 1,
    MEDIUM: 2,
    HIGH: 3,
    CRITICAL: 4
};
const DANGEROUS_SPECIES = ["T-Rex", "Velociraptor", "Dilophosaurus"];

// Funkcja monitorująca park
function monitorPark() {
    // Stan parku - może się zmieniać
    let isOpen = true;
    let visitorCount = getCurrentVisitors();
    let activeAlerts = [];

    // Przegląd każdego sektora
    for (let i = 0; i < parkSectors.length; i++) {
        const sector = parkSectors[i];  // Referencja do sektora nie zmienia się w pętli
        let sectorStatus = checkSectorStatus(sector);

        // Sprawdź dinozaury w sektorze
        for (const dinosaur of sector.dinosaurs) {
            // Species jest stałe - nie zmienia się
            const species = dinosaur.species;

            // Poziom zagrożenia może się zmieniać
            let dangerLevel = DANGER_LEVELS.LOW;

            // Ocena zagrożenia
            if (DANGEROUS_SPECIES.includes(species)) {
                dangerLevel = DANGER_LEVELS.HIGH;

                // Sprawdź infrastrukturę bezpieczeństwa
                const fenceStatus = checkFenceStatus(sector.id);
                const powerStatus = checkPowerStatus(sector.id);

                if (fenceStatus !== "Operational" || powerStatus < 90) {
                    dangerLevel = DANGER_LEVELS.CRITICAL;

                    // Lokalny protokół awaryjny
                    let emergencyProtocol = selectEmergencyProtocol(species);
                    activeAlerts.push({
                        sector: sector.id,
                        species: species,
                        protocol: emergencyProtocol
                    });

                    // Dodanie alertu może wpłynąć na status parku
                    if (dangerLevel === DANGER_LEVELS.CRITICAL) {
                        isOpen = false;
                    }
                }
            }
        }
    }

    // Zwróć raport statusu parku
    return {
        parkName: PARK_NAME,
        open: isOpen,
        visitors: visitorCount,
        alerts: activeAlerts
    };
}

Podsumowanie

  1. var:

    • Ma zakres funkcyjny
    • Jest w pełni hoistowane (wyniesione)
    • Pozwala na ponowną deklarację
    • Jak starsze, mniej bezpieczne zagrody w parku
  2. let:

    • Ma zakres blokowy
    • Jest częściowo hoistowane (nie można używać przed deklaracją)
    • Nie pozwala na ponowną deklarację w tym samym zakresie
    • Jak standardowe zagrody z możliwością modyfikacji
  3. const:

    • Ma zakres blokowy
    • Jest częściowo hoistowane (nie można używać przed deklaracją)
    • Nie pozwala na ponowną deklarację ani nadpisanie wartości
    • Pozwala na modyfikację zawartości obiektów i tablic
    • Jak wzmocnione zagrody dla najniebezpieczniejszych dinozaurów

Wybór między var, let i const jest jak wybór odpowiednich zabezpieczeń w Parku Jurajskim - zależy od konkretnych potrzeb, ale zawsze warto zaczynać od najsilniejszych (const) i rozluźniać je tylko wtedy, gdy jest to absolutnie konieczne.

W następnej lekcji przyjrzymy się podstawowym typom danych w JavaScript, które są jak różne gatunki dinozaurów w naszym parku - każdy z nich ma swoje unikalne cechy i zastosowania.

Kod do tej lekcji: index.js
// Patrol Parku - Pętle i Iteracja
// Ćwiczenie: Używanie pętli for, while, for...of

// Pętla for - klasyczna iteracja
console.log("=== Patrol Zagród (pętla for) ===");
const enclosures = ["T-Rex", "Raptor", "Triceratops", "Brachio", "Stego"];

for (let i = 0; i < enclosures.length; i++) {
  console.log("Zagroda " + (i + 1) + ": " + enclosures[i] + " - OK");
}

// Pętla for...of - iteracja po elementach
console.log("\n=== Karmienie (for...of) ===");
for (const dino of enclosures) {
  console.log("Karmienie: " + dino);
}

// Pętla while
console.log("\n=== Skanowanie DNA (while) ===");
let samples = 3;
while (samples > 0) {
  console.log("Skanowanie próbki " + samples + "...");
  samples--;
}

// Twoje zadanie:
// 1. Użyj pętli for do przeszukania bazy DNA
// 2. Użyj for...of do wypisania gatunków
// 3. Użyj while z warunkiem zatrzymania

// Twój kod tutaj:

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. Co to jest zmienna w JavaScript?

  2. 2. Które słowo kluczowe deklaracji zmiennej zapobiega ponownemu przypisaniu wartości?

  3. 3. Czy JavaScript rozróżnia wielkie i małe litery?

Zadania praktyczne w grze

  • Edytor kodu

    Stwórz zmienne: const labName = 'InGen', let dinoSpecies = 'Velociraptor', let population = 8. Wyświetl wszystkie w konsoli używając console.log().

  • Klikanie w kolejności

    Ułóż elementy deklaracji stałej w prawidłowej kolejności:

  • Układanie w poziomie

    Ułóż elementy deklaracji zmiennej z przypisaniem:

  • Edytor kodu

    Stwórz zmienną species i zapisz w niej nazwę gatunku dinozaura jako tekst, np. 'Tyrannosaurus Rex'.

  • Układanie w pionie

    Uporządkuj etapy pracy ze zmiennymi w JavaScript:

  • Klikanie w kolejności

    Ułóż elementy deklaracji zmiennej z let:

  1. PytanieZmienna w JavaScript
  2. PytanieZmienne w JavaScript - const
  3. PytanieWielkość liter w JavaScript
  4. Zadanie z kodemPraktyka: Pierwsza zmienna
  5. Kliknij w kolejnościSortowanie: Deklaracja zmiennej const
  6. Ułóż w kolejnościSkładnia deklaracji zmiennej
  7. Zadanie z kodemĆwiczenie: Stwórz zmienną przechowującą gatunek dinozaura
  8. Ułóż w kolejnościEtapy pracy ze zmiennymi
  9. Kliknij w kolejnościSortowanie: Deklaracja zmiennej let

Przydatne artykuły