Kurs JavaScript i TypeScript · Moduł 1: Podstawy JavaScript

Instrukcje i bloki kodu

6 min czytania ·
W tej lekcji8

W parku pełnym dinozaurów, każdy krok musi być dokładnie zaplanowany i wykonany we właściwej kolejności. Tak samo jest w JavaScript - kod wykonuje się jako sekwencja instrukcji, które muszą być odpowiednio ustrukturyzowane, aby program działał poprawnie i bezpiecznie.

Instrukcje w JavaScript

Instrukcja (statement) w JavaScript to komenda, która wykonuje określone zadanie. Jest to jak pojedynczy rozkaz wydany pracownikowi Parku Jurajskiego - na przykład "nakarm T-Rexa" lub "sprawdź ogrodzenie".

W JavaScript każda instrukcja zwykle kończy się średnikiem (choć, jak zobaczymy w następnej lekcji, jest to czasem opcjonalne):

let dinosaurCount = 5;       // Deklaracja zmiennej
console.log("Uwaga!");       // Wywołanie funkcji
dinosaurCount++;             // Inkrementacja wartości

Instrukcje wykonywane są w kolejności, w jakiej zostały zapisane - od góry do dołu. To jak procedura bezpieczeństwa w Parku Jurajskim, gdzie kroki muszą być wykonywane w ściśle określonej kolejności:

// Procedura zamykania zagrody T-Rexa
verifyDinosaurLocation();    // 1. Sprawdź położenie dinozaura
activateGates();             // 2. Aktywuj bramy
closeFencedArea();           // 3. Zamknij ogrodzony obszar
verifyEnclosureSecurity();   // 4. Sprawdź bezpieczeństwo zagrody

Bloki kodu w JavaScript

Blok kodu to grupa instrukcji zawarta w nawiasach klamrowych { }. Działa jak ogrodzona strefa w Parku Jurajskim - wydziela określony obszar, który ma swoje własne zasady i ograniczenia.

// Blok kodu kontrolujący procedurę przeglądu zdrowia dinozaurów
{
    let healthStatus = checkDinosaurVitals();
    updateMedicalRecords(healthStatus);

    if (healthStatus === "Krytyczny") {
        alertVeterinaryTeam();
    }
}

Bloków kodu używamy głównie w czterech sytuacjach:

1. Funkcje

Funkcje to kluczowe "procedury" w naszym parku, które można wykonywać wielokrotnie:

function feedCarnivore(dinosaurType, foodAmount) {
    // Ten blok kodu definiuje procedurę karmienia mięsożercy
    console.log(`Przygotowanie posiłku dla ${dinosaurType}`);
    prepareMeat(foodAmount);
    openFeedingHatch();
    closeFeedingHatch();
    console.log("Karmienie zakończone");
}

2. Instrukcje warunkowe

Podobnie jak decyzje personelu parku zależą od różnych sytuacji, tak w JavaScript używamy bloków kodu z instrukcjami warunkowymi:

if (rainLevel > 50) {
    // Ten blok wykonuje się tylko podczas silnych opadów
    evacuateOpenAreas();
    secureOutdoorEquipment();
    activateEmergencyShelters();
}

3. Pętle

Gdy w parku trzeba przeprowadzić tę samą procedurę dla wielu zagród czy dinozaurów, używa się pętli:

for (let i = 0; i < parkSectors.length; i++) {
    // Ten blok wykonuje się dla każdego sektora parku
    checkSecuritySystems(parkSectors[i]);
    updateSecurityLogs(parkSectors[i]);
}

4. Bloki leksykalne

Czasem bloków kodu używamy tylko po to, by ograniczyć zakres zmiennych - podobnie jak w parku mamy strefy o ograniczonym dostępie:

{
    // Zmienne zadeklarowane tutaj są dostępne tylko wewnątrz tego bloku
    let securityCode = "TRex2023";
    activateSecurityProtocol(securityCode);
}
// Zmienna securityCode nie jest już dostępna tutaj

Zakres (scope) zmiennych

Bloki kodu mają kluczowe znaczenie dla zakresu zmiennych zadeklarowanych za pomocą let i const. Zmienne te są widoczne tylko wewnątrz bloku, w którym zostały zadeklarowane.

To jak pracownicy mający dostęp tylko do określonych stref w Parku Jurajskim:

{
    // Laboratorium genetyczne - dostęp tylko dla upoważnionych
    let dinoGenomeSequence = "ACGTACGT...";

    // Zmienna jest dostępna tylko tutaj
    modifyDinoGenome(dinoGenomeSequence);
}

// Błąd! Ta zmienna nie jest dostępna poza laboratorium
// console.log(dinoGenomeSequence);

Dla lepszego zobrazowania, porównajmy zakresy zmiennych do stref bezpieczeństwa w parku:

// Strefa ogólnodostępna (globalny zakres)
let parkName = "Jurassic Park";

function checkParkStatus() {
    // Strefa dla pracowników (zakres funkcji)
    let isOpen = true;
    let visitorCount = 368;

    if (visitorCount > 350) {
        // Strefa kontroli tłumu (zakres bloku)
        let alertLevel = "Żółty";
        console.log(`Alert poziomu: ${alertLevel}`);
    }

    // alertLevel nie jest tu dostępny - błąd!
    // console.log(alertLevel);
}

// Ani isOpen, ani visitorCount nie są tu dostępne - błąd!
// console.log(isOpen);

Zagnieżdżanie bloków

Bloki kodu mogą być również zagnieżdżone (bloki wewnątrz bloków), podobnie jak w Parku Jurajskim mamy strefy wewnątrz innych stref:

// Strefa pracownicza
{
    let employeeAccessLevel = 2;

    // Strefa genetyczna - wyższy poziom dostępu
    if (employeeAccessLevel >= 3) {
        let geneticLabAccess = true;

        // Wysokie bezpieczeństwo - ścisła kontrola
        if (geneticLabAccess) {
            let embryoStorageCode = "LS-445-23A";
            console.log(`Kod dostępu: ${embryoStorageCode}`);
        }
    }
}

Hoisting i deklaracje

W JavaScript występuje mechanizm zwany "hoisting" - deklaracje zmiennych i funkcji są "podnoszone" na górę ich zakresu. Jednak wartości przypisane do zmiennych nie są podnoszone.

To jak przygotowanie wszystkich procedur bezpieczeństwa przed otwarciem parku:

// Ta funkcja jest dostępna tutaj dzięki hoistingowi
securityCheck();

// Deklaracja funkcji
function securityCheck() {
    console.log("Systemy bezpieczeństwa sprawdzone");
}

// Zmienne zadeklarowane przez var są "podnoszone"
console.log(parkStatus); // undefined, ale nie błąd
var parkStatus = "Otwarty";

// let i const NIE są w pełni podnoszone
// console.log(dinosaurCount); // Błąd: Cannot access 'dinosaurCount' before initialization
let dinosaurCount = 20;

Wyrażenia vs Instrukcje

W JavaScript ważne jest rozróżnienie między instrukcjami a wyrażeniami:

  • Wyrażenie (expression) to kod, który zwraca wartość, jak badanie próbki DNA, które zwraca wynik
  • Instrukcja (statement) to komenda, która wykonuje akcję, jak procedura karmienia dinozaura
// Wyrażenia - zwracają wartość
5 + 3                        // Wyrażenie, które zwraca 8
dinosaurWeight * 0.5         // Wyrażenie, które zwraca połowę wagi
isDangerousSpecies("T-Rex")  // Wyrażenie, które zwraca true

// Instrukcje - wykonują akcje
let visitorsToday = 500;     // Instrukcja deklaracji
if (visitorsToday > 400) {   // Instrukcja warunkowa
    activateCrowdControl();
}

Praktyczne zastosowanie

Zrozumienie instrukcji i bloków kodu jest jak poznanie mapy Parku Jurajskiego - pozwala bezpiecznie nawigować przez kod. Oto przykład złożonego kodu z wykorzystaniem instrukcji, bloków i różnych zakresów:

// System monitorowania parku

// Zmienne globalne
const parkName = "Jurassic Park";
let parkStatus = "Otwarty";
let globalAlertLevel = "Normalny";

// Funkcja głównego monitoringu
function monitorParkSystems() {
    let systemsOnline = true;

    // Sprawdzenie ogrodzeń
    checkElectricalFences();

    // Blok monitorowania dinozaurów
    {
        let activeDinosaurs = getDinosaurStatus();

        // Pętla sprawdzająca każdego dinozaura
        for (let i = 0; i < activeDinosaurs.length; i++) {
            let dinosaur = activeDinosaurs[i];

            // Blok warunków dla niebezpiecznych gatunków
            if (dinosaur.dangerLevel > 3) {
                // Wewnętrzny blok procedur awaryjnych
                {
                    let emergencyProtocol = `Protokół-${dinosaur.species}`;
                    console.log(`Aktywacja: ${emergencyProtocol}`);

                    // Ta zmienna jest dostępna tylko tutaj
                    let emergencyTeam = selectTeamForSpecies(dinosaur.species);
                    alertSecurityTeam(emergencyTeam);
                }

                // Zmienna emergencyTeam nie jest dostępna tutaj
                updateSecurityLogs(dinosaur);
            }
        }
    }

    // Zmienne z bloku monitorowania dinozaurów nie są tu dostępne
    return generateStatusReport();
}

// Funkcja pomocnicza
function checkElectricalFences() {
    let sections = 12;
    let failedSections = 0;

    for (let i = 1; i <= sections; i++) {
        let sectionStatus = getFenceStatus(i);

        if (sectionStatus !== "Aktywny") {
            failedSections++;

            // Blok awaryjny
            {
                let repairTeam = "Echo";
                dispatchRepairTeam(repairTeam, i);
            }
        }
    }

    if (failedSections > 0) {
        globalAlertLevel = "Podwyższony";
    }
}

W powyższym przykładzie widać, jak bloków kodu można użyć do organizacji kodu, kontrolowania zakresu zmiennych i tworzenia logicznej struktury programu. Każdy blok działa jak oddzielna strefa w parku, z własnymi zasadami i ograniczeniami.

Podsumowanie

Instrukcje i bloki kodu w JavaScript są jak procedury bezpieczeństwa i strefy w Parku Jurajskim - utrzymują porządek, organizację i bezpieczeństwo. Dobrze zorganizowany kod, wykorzystujący odpowiednio instrukcje i bloki, jest łatwiejszy do zrozumienia, utrzymania i rozwijania.

Najważniejsze koncepcje do zapamiętania:

  1. Instrukcje to pojedyncze komendy zakończone średnikiem
  2. Bloki kodu to grupy instrukcji zawarte w nawiasach klamrowych { }
  3. Zakres zmiennych jest ograniczony przez blok, w którym zostały zadeklarowane (dla let i const)
  4. Hoisting to mechanizm "podnoszenia" deklaracji zmiennych i funkcji
  5. Wyrażenia zwracają wartość, podczas gdy instrukcje wykonują akcje

W następnej lekcji przyjrzymy się bliżej średnikom w JavaScript oraz ich opcjonalności, co jest jak poznanie niuansów w protokołach bezpieczeństwa parku - czasem są absolutnie niezbędne, a innym razem można je pominąć.

Kod do tej lekcji: index.js
// Zagrody Parku - Praca z Tablicami
// Ćwiczenie: Tworzenie tablic i używanie metod tablicowych

// Tablica to uporządkowana kolekcja elementów
const dinosaurs = ["T-Rex", "Velociraptor", "Triceratops", "Brachiosaurus"];
console.log("Dinozaury w parku:", dinosaurs);
console.log("Pierwszy:", dinosaurs[0]);
console.log("Ostatni:", dinosaurs[dinosaurs.length - 1]);

// Metody tablicowe
dinosaurs.push("Stegosaurus");
console.log("Po dodaniu:", dinosaurs);

const removed = dinosaurs.pop();
console.log("Usunięto:", removed);

// Przeszukiwanie
console.log("Czy jest T-Rex?", dinosaurs.includes("T-Rex"));
console.log("Indeks Triceratops:", dinosaurs.indexOf("Triceratops"));

// Twoje zadanie:
// 1. Stwórz tablicę gatunków w zagrodzie
// 2. Dodaj i usuń elementy używając push/pop/shift/unshift
// 3. Znajdź element w tablicy

// 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. Czym jest blok kodu w JavaScript?

Zadania praktyczne w grze

  • Układanie w pionie

    Uporządkuj elementy struktury bloku kodu w funkcji JavaScript:

  • Klikanie w kolejności

    Uporządkuj program: komentarz, stała, definicja funkcji i jej wywołanie:

  • Układanie w pionie

    Uporządkuj kroki w procesie programowania:

  1. PytanieBloki kodu w JavaScript
  2. Ułóż w kolejnościStruktura bloku kodu w funkcji
  3. Kliknij w kolejnościStruktura programu JavaScript
  4. Ułóż w kolejnościKroki w procesie programowania

Przydatne artykuły