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

Zasięg zmiennych (globalny, funkcyjny, blokowy)

10 min czytania ·
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:

  1. Zasięg globalny (Global scope)
  2. Zasięg funkcyjny (Function scope)
  3. 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:

  • var ma zasięg funkcyjny, ale nie blokowy
  • let i const mają 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:

  1. 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
  2. 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)
  3. 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ępna

Zasady dobrej praktyki

  1. Unikaj zmiennych globalnych - podobnie jak w rzeczywistym parku, im więcej publicznych obszarów, tym trudniej je monitorować i zabezpieczyć.

  2. Preferuj const nad let, a let nad var - większość zmiennych nie powinna zmieniać swoich wartości, a jeśli już, to powinny mieć jak najmniejszy zasięg.

  3. Używaj zasięgu blokowego - ograniczaj widoczność zmiennych do najmniejszego możliwego zakresu.

  4. Stosuj wzorzec modułu - enkapsuluj zmienne i funkcje w modułach, udostępniając tylko niezbędne API.

  5. 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. 1. Która deklaracja zmiennej jest najlepsza dla stałej wartości gatunku dinozaura?

  2. 2. Co zwróci następujący kod: String(65000000)?

  3. 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).

  1. PytanieConst vs Let vs Var
  2. PytanieKonwersja typów
  3. Zadanie z kodemĆwiczenie: Konwersja typów
  4. PytanieDopasowanie typów danych

Przydatne artykuły