Kurs JavaScript i TypeScript · Moduł 1: Podstawy JavaScript
Deklaracja zmiennych (var, let, const)
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 funkcyjnyTo 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 miejscu2. 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ż zadeklarowaneTo 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
var:
- Ma zakres funkcyjny
- Jest w pełni hoistowane (wyniesione)
- Pozwala na ponowną deklarację
- Jak starsze, mniej bezpieczne zagrody w parku
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
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. Co to jest zmienna w JavaScript?
2. Które słowo kluczowe deklaracji zmiennej zapobiega ponownemu przypisaniu wartości?
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:
Zadania po tej lekcji
- PytanieZmienna w JavaScript
- PytanieZmienne w JavaScript - const
- PytanieWielkość liter w JavaScript
- Zadanie z kodemPraktyka: Pierwsza zmienna
- Kliknij w kolejnościSortowanie: Deklaracja zmiennej const
- Ułóż w kolejnościSkładnia deklaracji zmiennej
- Zadanie z kodemĆwiczenie: Stwórz zmienną przechowującą gatunek dinozaura
- Ułóż w kolejnościEtapy pracy ze zmiennymi
- Kliknij w kolejnościSortowanie: Deklaracja zmiennej let