Kurs JavaScript i TypeScript · Moduł 2: Funkcje, tablice i obiekty
Zasięg zmiennych (globalny, funkcyjny, blokowy)
W tej lekcji8
Witaj ponownie w Parku Jurajskim! Dzisiaj zajmiemy się jednym z fundamentalnych konceptów JavaScript - zasięgiem zmiennych. Zrozumienie zasięgu zmiennych jest kluczowe dla pisania wydajnego, bezpiecznego i przewidywalnego kodu, szczególnie w złożonych systemach, takich jak nasz park pełen dinozaurów.
Czym jest zasięg zmiennych?
Zasięg zmiennych (scope) określa, gdzie w kodzie dana zmienna jest dostępna - innymi słowy, z którego miejsca w kodzie możemy się do niej odwołać. Podobnie jak w Parku Jurajskim mamy strefy z różnymi poziomami dostępu (strefa dla zwiedzających, laboratorium tylko dla naukowców, zagrody wymagające specjalnych uprawnień), tak w JavaScript mamy różne zasięgi dostępu do zmiennych.
W JavaScript wyróżniamy trzy główne typy zasięgów:
- Zasięg globalny (Global scope)
- Zasięg funkcyjny (Function scope)
- Zasięg blokowy (Block scope)
Zasięg globalny
Zmienne zdefiniowane poza jakąkolwiek funkcją lub blokiem kodu mają zasięg globalny. Oznacza to, że są dostępne w całym programie, w każdej funkcji i bloku kodu.
// Zmienne globalne - dostępne wszędzie, jak publiczne informacje o parku
const parkName = "Jurassic Park";
let visitorCount = 0;
var isOpenToPublic = true;
function checkParkStatus() {
console.log(`Nazwa parku: ${parkName}`);
console.log(`Liczba odwiedzających: ${visitorCount}`);
console.log(`Otwarty dla zwiedzających: ${isOpenToPublic}`);
}
function updateVisitorCount(newCount) {
// Możemy modyfikować zmienną globalną z dowolnej funkcji
visitorCount = newCount;
console.log(`Zaktualizowano liczbę odwiedzających: ${visitorCount}`);
}
// Wywołanie funkcji korzystających z globalnych zmiennych
checkParkStatus();
updateVisitorCount(250);
checkParkStatus();Należy być ostrożnym ze zmiennymi globalnymi, ponieważ:
- Mogą być przypadkowo zmodyfikowane z dowolnego miejsca w kodzie
- Mogą prowadzić do konfliktów nazw
- Utrudniają śledzenie stanu aplikacji
- Zwiększają powiązania między różnymi częściami kodu
Zmienne globalne w naszym parku to jak dokumenty dostępne dla wszystkich pracowników - czasami są niezbędne, ale zbyt wiele takich dokumentów może prowadzić do bałaganu i nieporozumień.
Zasięg funkcyjny
Zmienne zdefiniowane wewnątrz funkcji są dostępne tylko wewnątrz tej funkcji. Są to zmienne lokalne dla danej funkcji.
function monitorDinosaur(dinoId) {
// Te zmienne mają zasięg funkcyjny - są dostępne tylko wewnątrz tej funkcji
const startTime = Date.now();
let status = "Monitorowanie...";
var sensorData = [];
// Możemy używać zmiennych wewnątrz funkcji
status = "Zbieranie danych...";
sensorData.push({ time: startTime, temperature: 37.5 });
console.log(`Status: ${status}`);
console.log(`Dane z czujników: ${JSON.stringify(sensorData)}`);
// Zwracamy wynik
return {
id: dinoId,
monitoringStarted: startTime,
lastStatus: status
};
}
// Wywołanie funkcji
const monitoringResults = monitorDinosaur("T-Rex-01");
// Poniższy kod spowodowałby błąd, ponieważ próbujemy uzyskać dostęp
// do zmiennych o zasięgu funkcyjnym z zewnątrz funkcji
// console.log(startTime); // ReferenceError
// console.log(status); // ReferenceError
// console.log(sensorData); // ReferenceError
// Ale mamy dostęp do wartości zwracanej przez funkcję
console.log(monitoringResults);Zasięg funkcyjny działa jak strefy zastrzeżone w parku - tylko upoważniony personel (kod wewnątrz funkcji) ma dostęp do informacji i zasobów w tej strefie.
Różnica między var, let i const w kontekście zasięgu funkcyjnego
Wszystkie trzy słowa kluczowe (var, let, const) tworzą zmienne o zasięgu funkcyjnym, ale jest między nimi istotna różnica:
varma zasięg funkcyjny, ale nie blokowyleticonstmają zarówno zasięg funkcyjny jak i blokowy
Zobaczmy to na przykładzie:
function securityCheck() {
// Wszystkie te zmienne są dostępne wewnątrz całej funkcji
var securityCode = "A1B2C3";
let accessLevel = 5;
const securityChief = "Robert Muldoon";
if (accessLevel >= 5) {
var emergencyProtocol = "Code Red"; // zasięg funkcyjny!
let backupSystem = "Operational"; // zasięg blokowy
const safeRoom = "Bunker B"; // zasięg blokowy
console.log(securityCode); // A1B2C3 - dostępne
console.log(accessLevel); // 5 - dostępne
console.log(securityChief); // Robert Muldoon - dostępne
}
console.log(emergencyProtocol); // Code Red - dostępne mimo że zdefiniowane w bloku if
// console.log(backupSystem); // ReferenceError - zmienna ma zasięg blokowy
// console.log(safeRoom); // ReferenceError - zmienna ma zasięg blokowy
}
securityCheck();Zasięg blokowy
Zasięg blokowy został wprowadzony w ES6 (ES2015) wraz z nowymi słowami kluczowymi let i const. Zmienne zdefiniowane za pomocą let i const wewnątrz bloku kodu (ograniczonego nawiasami klamrowymi {}) są dostępne tylko wewnątrz tego bloku.
function monitorDinosaurBehavior() {
let dangerLevel = 0;
// Blok if - tworzy nowy zasięg
if (true) {
// Zasięg blokowy - zmienne dostępne tylko wewnątrz tego bloku
let behavior = "Spokojne";
const vitals = { heartRate: 80, temperature: 38 };
// Modyfikacja zmiennej z zewnętrznego zasięgu
dangerLevel = behavior === "Agresywne" ? 5 : 1;
console.log(behavior); // Spokojne - dostępne
console.log(vitals); // { heartRate: 80, temperature: 38 } - dostępne
console.log(dangerLevel); // 1 - dostępne
}
console.log(dangerLevel); // 1 - dostępne bo zdefiniowane w szerszym zasięgu
// console.log(behavior); // ReferenceError - zmienna ma zasięg blokowy
// console.log(vitals); // ReferenceError - zmienna ma zasięg blokowy
// Blok for - również tworzy nowy zasięg
for (let i = 0; i < 5; i++) {
// 'i' ma zasięg blokowy, dostępne tylko wewnątrz pętli
const sensorId = `Sensor-${i}`;
console.log(sensorId);
}
// console.log(i); // ReferenceError - 'i' ma zasięg blokowy
// console.log(sensorId); // ReferenceError - zmienna ma zasięg blokowy
}
monitorDinosaurBehavior();Zasięg blokowy jest jak poszczególne zagrody w naszym parku - każda zagroda ma własne zasady i dostęp, a wyposażenie przypisane do jednej zagrody nie jest dostępne w innych zagrodach.
Różnica między var, let i const
Teraz możemy lepiej zrozumieć różnice między tymi trzema słowami kluczowymi:
var:- Ma zasięg funkcyjny lub globalny, ale nie blokowy
- Może być redeklarowana wielokrotnie
- Może być modyfikowana
- Jest hoistowana (wynoszona) z przypisaniem wartości
undefined
let:- Ma zasięg blokowy
- Nie może być redeklarowana w tym samym zasięgu
- Może być modyfikowana
- Jest hoistowana bez przypisania wartości (temporal dead zone)
const:- Ma zasięg blokowy
- Nie może być redeklarowana w tym samym zasięgu
- Nie może być modyfikowana (ale właściwości obiektów mogą być modyfikowane)
- Jest hoistowana bez przypisania wartości (temporal dead zone)
function demonstrateVariables() {
// var
var dinosaur = "T-Rex";
var dinosaur = "Velociraptor"; // OK - można redeklarować
dinosaur = "Triceratops"; // OK - można modyfikować
// let
let park = "Jurassic Park";
// let park = "Dino World"; // Błąd - nie można redeklarować
park = "Jurassic World"; // OK - można modyfikować
// const
const island = "Isla Nublar";
// const island = "Isla Sorna"; // Błąd - nie można redeklarować
// island = "Another Island"; // Błąd - nie można modyfikować
// Ale właściwości obiektów const mogą być modyfikowane
const parkSystem = {
mainPower: true,
backupGenerator: false
};
// To jest dozwolone
parkSystem.mainPower = false;
parkSystem.backupGenerator = true;
console.log(parkSystem); // { mainPower: false, backupGenerator: true }
}
demonstrateVariables();Zasięg leksykalny i domknięcia (closures)
JavaScript wykorzystuje zasięg leksykalny, co oznacza, że funkcje mogą uzyskać dostęp do zmiennych zdefiniowanych w ich zewnętrznym zakresie.
function initSecuritySystem() {
// Zmienne w zasięgu funkcji zewnętrznej
const systemName = "JurassicSafe";
let isActive = false;
let alertLevel = 0;
// Funkcja wewnętrzna ma dostęp do zmiennych z funkcji zewnętrznej
function activateSystem() {
isActive = true;
console.log(`System ${systemName} został aktywowany.`);
return true;
}
// Jeszcze jedna funkcja wewnętrzna
function setAlertLevel(level) {
alertLevel = level;
console.log(`System ${systemName}: poziom alertu ustawiony na ${alertLevel}`);
}
// Zwracamy funkcje wewnętrzne
return {
activate: activateSystem,
setAlert: setAlertLevel,
getStatus: function() {
return {
name: systemName,
active: isActive,
alertLevel: alertLevel
};
}
};
}
// Tworzymy instancję systemu bezpieczeństwa
const securitySystem = initSecuritySystem();
// Używamy zwróconych funkcji
securitySystem.activate(); // System JurassicSafe został aktywowany.
securitySystem.setAlert(3); // System JurassicSafe: poziom alertu ustawiony na 3
console.log(securitySystem.getStatus()); // { name: "JurassicSafe", active: true, alertLevel: 3 }W powyższym przykładzie funkcje wewnętrzne tworzą domknięcie (closure) nad zmiennymi z funkcji initSecuritySystem. Nawet po zakończeniu wykonania initSecuritySystem, zwrócone funkcje nadal mają dostęp do tych zmiennych.
Domknięcia są jak zespoły bezpieczeństwa w parku - nawet gdy opuszczą centrum dowodzenia, nadal mają dostęp do kodów i protokołów, które zabrali ze sobą.
Praktyczny przykład: System zarządzania parkiem
Stwórzmy bardziej kompleksowy przykład, który demonstruje różne zasięgi zmiennych w kontekście systemu zarządzania parkiem:
// Zmienne globalne - dostępne w całym programie
const PARK_NAME = "Jurassic Park";
let parkStatus = "closed";
var totalVisitors = 0;
// Funkcja IIFE (Immediately Invoked Function Expression) tworząca moduł
const parkSystem = (function() {
// Zmienne prywatne - zasięg funkcyjny, niedostępne spoza modułu
let securityStatus = "active";
let powerStatus = "online";
const MAX_CAPACITY = 2000;
// Prywatna funkcja pomocnicza
function checkSystemStatus() {
return powerStatus === "online" && securityStatus === "active";
}
// Publiczne API modułu
return {
// Metoda otwierająca park dla zwiedzających
openPark: function() {
if (checkSystemStatus()) {
parkStatus = "open"; // Modyfikacja zmiennej globalnej
console.log(`${PARK_NAME} jest teraz otwarty dla zwiedzających!`);
return true;
} else {
console.log("Nie można otworzyć parku - systemy bezpieczeństwa nie są w pełni operacyjne.");
return false;
}
},
// Metoda rejestrująca nowych odwiedzających
registerVisitors: function(count) {
// Sprawdzenie pojemności parku
if (parkStatus !== "open") {
console.log("Park jest zamknięty. Nie można zarejestrować odwiedzających.");
return false;
}
// Zmienna z zasięgiem blokowym
const availableCapacity = MAX_CAPACITY - totalVisitors;
if (count <= availableCapacity) {
totalVisitors += count; // Modyfikacja zmiennej globalnej
console.log(`Zarejestrowano ${count} nowych odwiedzających. Łącznie: ${totalVisitors}`);
// Zasięg blokowy wewnątrz warunku
if (totalVisitors > MAX_CAPACITY * 0.8) {
const warningMessage = "Uwaga: Park zbliża się do maksymalnej pojemności!";
console.log(warningMessage);
}
return true;
} else {
console.log(`Błąd: Za dużo odwiedzających. Dostępna pojemność: ${availableCapacity}`);
return false;
}
},
// Metoda zamykająca park
closePark: function() {
// Funkcja lokalna z dostępem do zmiennych z szerszego zakresu
function evacuateVisitors() {
console.log(`Ewakuowanie ${totalVisitors} odwiedzających z parku...`);
totalVisitors = 0;
}
parkStatus = "closed";
evacuateVisitors();
console.log(`${PARK_NAME} został zamknięty.`);
return true;
},
// Metoda zmieniająca status systemów
updateSystems: function(power, security) {
// Dla demonstracji let vs var
if (power) {
let localMessage = "Aktualizacja systemu zasilania...";
console.log(localMessage);
powerStatus = power;
}
if (security) {
var statusMessage = "Aktualizacja systemu bezpieczeństwa...";
console.log(statusMessage);
securityStatus = security;
}
// console.log(localMessage); // Błąd: localMessage ma zasięg blokowy
console.log(statusMessage); // Działa: statusMessage ma zasięg funkcyjny
return {
power: powerStatus,
security: securityStatus
};
}
};
})();
// Korzystanie z naszego systemu
console.log(`Status parku przed otwarciem: ${parkStatus}`);
parkSystem.openPark();
console.log(`Status parku po otwarciu: ${parkStatus}`);
parkSystem.registerVisitors(500);
parkSystem.registerVisitors(1200); // Powinien pokazać ostrzeżenie o pojemności
parkSystem.registerVisitors(400); // Powinien pokazać błąd o przekroczeniu pojemności
// Aktualizacja systemów
parkSystem.updateSystems("offline", null);
parkSystem.openPark(); // Powinien pokazać błąd - nie można otworzyć parku
// Przywrócenie systemów i zamknięcie parku
parkSystem.updateSystems("online", "active");
parkSystem.closePark();
console.log(`Status parku po zamknięciu: ${parkStatus}`);
console.log(`Liczba odwiedzających po ewakuacji: ${totalVisitors}`);
// Próba dostępu do zmiennych prywatnych
// console.log(securityStatus); // Błąd: zmienna niedostępna
// console.log(MAX_CAPACITY); // Błąd: zmienna niedostępnaZasady dobrej praktyki
Unikaj zmiennych globalnych - podobnie jak w rzeczywistym parku, im więcej publicznych obszarów, tym trudniej je monitorować i zabezpieczyć.
Preferuj
constnadlet, aletnadvar- większość zmiennych nie powinna zmieniać swoich wartości, a jeśli już, to powinny mieć jak najmniejszy zasięg.Używaj zasięgu blokowego - ograniczaj widoczność zmiennych do najmniejszego możliwego zakresu.
Stosuj wzorzec modułu - enkapsuluj zmienne i funkcje w modułach, udostępniając tylko niezbędne API.
Bądź świadomy domknięć - domknięcia są potężnym narzędziem, ale mogą prowadzić do wycieków pamięci, jeśli są używane nieprawidłowo.
Podsumowanie
Zasięg zmiennych w JavaScript jest jak system stref dostępu w Parku Jurajskim:
- Zasięg globalny - jak publiczne obszary parku, dostępne dla wszystkich
- Zasięg funkcyjny - jak strefy zastrzeżone dla określonych pracowników
- Zasięg blokowy - jak poszczególne zagrody i laboratoria z własnym systemem dostępu
Zrozumienie zasięgu zmiennych pozwala nam pisać lepiej zorganizowany, bardziej bezpieczny i przewidywalny kod - podobnie jak dobre zarządzanie strefami w parku pełnym niebezpiecznych dinozaurów zwiększa bezpieczeństwo wszystkich.
W jednej z kolejnych lekcji zagłębimy się w temat hoistingu (wynoszenia), który jest ściśle związany z zasięgiem zmiennych i ma istotny wpływ na sposób działania kodu JavaScript.
Kod do tej lekcji: index.js
// Zasięg zmiennych - Park Jurajski
console.log("Laboratorium Zasięgów Zmiennych");
console.log("Zrozumienie scope w JavaScript\n");
// ===========================================
// 1. ZASIĘG GLOBALNY
// ===========================================
console.log("=== 1. Zasięg globalny ===");
const parkName = "Jurassic Park"; // Zmienna globalna
let totalDinosaurs = 0; // Zmienna globalna
function addDinosaur(name) {
totalDinosaurs++; // Dostęp do zmiennej globalnej
console.log(`Dodano ${name}. Łącznie dinozaurów: ${totalDinosaurs}`);
console.log(` W parku: ${parkName}`);
}
addDinosaur("T-Rex");
addDinosaur("Velociraptor");
addDinosaur("Triceratops");
console.log(`\nPark ${parkName} ma ${totalDinosaurs} dinozaurów`);
// ===========================================
// 2. ZASIĘG FUNKCYJNY
// ===========================================
console.log("\n=== 2. Zasięg funkcyjny ===");
function feedDinosaur(dinoName) {
const foodAmount = 50; // Zmienna lokalna funkcji
const message = `Karmienie ${dinoName} (porcja: ${foodAmount}kg)`;
console.log(`${message}`);
return foodAmount;
}
feedDinosaur("T-Rex");
feedDinosaur("Velociraptor");
// console.log(foodAmount); // ERROR: foodAmount is not defined
// console.log(message); // ERROR: message is not defined
// ===========================================
// 3. ZASIĘG BLOKOWY (let & const)
// ===========================================
console.log("\n=== 3. Zasięg blokowy (let & const) ===");
function checkSecurity(sector) {
console.log(`\nSprawdzanie zabezpieczeń sektora ${sector}`);
if (sector === "A") {
let dangerLevel = "HIGH"; // Zmienna blokowa
const dinosaurType = "T-Rex"; // Zmienna blokowa
console.log(` Poziom zagrożenia: ${dangerLevel}`);
console.log(` Typ dinozaura: ${dinosaurType}`);
}
// console.log(dangerLevel); // ERROR: dangerLevel is not defined
// console.log(dinosaurType); // ERROR: dinosaurType is not defined
console.log(` Sprawdzenie sektora ${sector} zakończone`);
}
checkSecurity("A");
checkSecurity("B");
// Przykład z pętlą for
console.log("\nPętla z let:");
for (let i = 0; i < 3; i++) {
console.log(` Iteracja ${i + 1}`);
}
// console.log(i); // ERROR: i is not defined
// ===========================================
// 4. var vs let vs const
// ===========================================
console.log("\n=== 4. Różnice: var vs let vs const ===");
function demonstrateScope() {
console.log("\nDemonstracja zasięgów:");
// var - zasięg funkcyjny (stary sposób)
if (true) {
var dinoVar = "T-Rex (var)";
let dinoLet = "Velociraptor (let)";
const dinoConst = "Triceratops (const)";
console.log(` W bloku - var: ${dinoVar}`);
console.log(` W bloku - let: ${dinoLet}`);
console.log(` W bloku - const: ${dinoConst}`);
}
console.log(`\n Poza blokiem - var: ${dinoVar}`); // Działa!
// console.log(` Poza blokiem - let: ${dinoLet}`); // ERROR
// console.log(` Poza blokiem - const: ${dinoConst}`); // ERROR
}
demonstrateScope();
// ===========================================
// 5. CLOSURE (DOMKNIĘCIA)
// ===========================================
console.log("\n=== 5. Closure (domknięcia) ===");
function createDinosaurCounter(startCount = 0) {
let count = startCount; // Zmienna prywatna
return {
add: function(name) {
count++;
console.log(`Dodano ${name}. Licznik: ${count}`);
},
remove: function(name) {
if (count > 0) {
count--;
console.log(`Usunięto ${name}. Licznik: ${count}`);
}
},
getCount: function() {
return count;
}
};
}
const sectorA = createDinosaurCounter(5);
const sectorB = createDinosaurCounter(0);
console.log("\nSektor A:");
sectorA.add("T-Rex");
sectorA.add("Velociraptor");
console.log(`Łącznie w sektorze A: ${sectorA.getCount()}`);
console.log("\nSektor B:");
sectorB.add("Triceratops");
console.log(`Łącznie w sektorze B: ${sectorB.getCount()}`);
// ===========================================
// 6. ZAGNIEŻDŻONE FUNKCJE
// ===========================================
console.log("\n=== 6. Zagnieżdżone funkcje i scope ===");
function managePark() {
const parkName = "Isla Nublar";
let visitors = 1000;
function openPark() {
console.log(`\n${parkName} otwarty dla ${visitors} odwiedzających`);
function welcomeVisitors() {
visitors += 50;
console.log(` Powitanie nowych gości. Teraz: ${visitors}`);
}
welcomeVisitors();
}
function closePark() {
console.log(`\nZamykanie ${parkName}`);
console.log(` Dzisiejszych odwiedzających: ${visitors}`);
}
openPark();
closePark();
}
managePark();
// ===========================================
// 7. SHADOWING (PRZESŁANIANIE)
// ===========================================
console.log("\n=== 7. Shadowing (przesłanianie zmiennych) ===");
const dinosaur = "T-Rex (globalny)";
function checkDinosaur() {
const dinosaur = "Velociraptor (funkcja)"; // Przesłania globalną
console.log(`W funkcji: ${dinosaur}`);
if (true) {
const dinosaur = "Triceratops (blok)"; // Przesłania funkcyjną
console.log(` W bloku: ${dinosaur}`);
}
console.log(` Po bloku: ${dinosaur}`);
}
console.log(`Globalnie: ${dinosaur}`);
checkDinosaur();
console.log(`Ponownie globalnie: ${dinosaur}`);
// ===========================================
// 8. LEXICAL SCOPE (ZASIĘG LEKSYKALNY)
// ===========================================
console.log("\n=== 8. Lexical scope ===");
const habitat = "Tropikalny las";
function outerFunction() {
const temperature = 28;
function innerFunction() {
const humidity = 80;
// Dostęp do wszystkich zmiennych z nadrzędnych zasięgów
console.log(`Środowisko: ${habitat}`);
console.log(` Temperatura: ${temperature}°C`);
console.log(` Wilgotność: ${humidity}%`);
}
innerFunction();
}
outerFunction();
// ===========================================
// 9. PRAKTYCZNY PRZYKŁAD - SYSTEM KARMIENIA
// ===========================================
console.log("\n=== 9. System karmienia - przykład praktyczny ===");
function createFeedingSystem() {
const feedingSchedule = [];
let lastFeedingTime = null;
return {
scheduleFeed: function(dinoName, time) {
const entry = { dino: dinoName, time: time, completed: false };
feedingSchedule.push(entry);
console.log(`Zaplanowano karmienie: ${dinoName} o ${time}`);
},
completeFeed: function(dinoName) {
const entry = feedingSchedule.find(e => e.dino === dinoName && !e.completed);
if (entry) {
entry.completed = true;
lastFeedingTime = new Date().toLocaleTimeString();
console.log(`Nakarmiono ${dinoName} o ${lastFeedingTime}`);
} else {
console.log(`Brak zaplanowanego karmienia dla ${dinoName}`);
}
},
getReport: function() {
console.log("\nRAPORT KARMIENIA:");
console.log(` Ostatnie karmienie: ${lastFeedingTime || "Brak"}`);
console.log(` Zaplanowane karmienia: ${feedingSchedule.length}`);
const pending = feedingSchedule.filter(e => !e.completed);
if (pending.length > 0) {
console.log("\n Oczekujące:");
pending.forEach(e => {
console.log(` - ${e.dino} o ${e.time}`);
});
}
}
};
}
const feedingSystem = createFeedingSystem();
feedingSystem.scheduleFeed("T-Rex", "08:00");
feedingSystem.scheduleFeed("Velociraptor", "10:00");
feedingSystem.scheduleFeed("Triceratops", "12:00");
feedingSystem.completeFeed("T-Rex");
feedingSystem.completeFeed("Velociraptor");
feedingSystem.getReport();
// ===========================================
// 10. BEST PRACTICES
// ===========================================
console.log("\n=== 10. Best practices ===");
// DOBRE: Używaj const dla wartości, które się nie zmieniają
const MAX_DINOSAURS = 50;
console.log(`Maksymalna liczba dinozaurów: ${MAX_DINOSAURS}`);
// DOBRE: Używaj let dla wartości zmiennych
let currentDinoCount = 15;
currentDinoCount += 5;
console.log(`Aktualna liczba: ${currentDinoCount}`);
// ZŁE: Unikaj var (stary sposób)
// var oldStyle = "Niepolecane";
// DOBRE: Ograniczaj zasięg zmiennych do minimum
function goodScope() {
const onlyHere = "Dostępne tylko tutaj";
return onlyHere;
}
console.log("\nGratulacje! Opanowałeś zasięg zmiennych!");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. Która deklaracja zmiennej jest najlepsza dla stałej wartości gatunku dinozaura?
2. Co zwróci następujący kod: String(65000000)?
3. Dr. Wu organizuje dane w laboratorium. Które dopasowanie rodzaju danych do typu JavaScript jest NIEPOPRAWNE?
Zadania praktyczne w grze
- Edytor kodu
Dane z formularza zawsze są tekstem: const inputWeight = '6200', const inputLength = '9.5' i const inputTeeth = '800'. Zamień je na liczby: numWeight przez Number(), numLength przez parseFloat() i numTeeth przez parseInt(). Potem zapisz w weightText wartość numWeight z powrotem jako tekst przez String(). Wyświetl w konsoli wszystkie cztery wartości razem z ich typem (typeof).