Kurs JavaScript i TypeScript · Moduł 1: Podstawy JavaScript
Instrukcje i bloki kodu
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ściInstrukcje 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 zagrodyBloki 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 tutajZakres (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:
- Instrukcje to pojedyncze komendy zakończone średnikiem
- Bloki kodu to grupy instrukcji zawarte w nawiasach klamrowych
{ } - Zakres zmiennych jest ograniczony przez blok, w którym zostały zadeklarowane (dla
leticonst) - Hoisting to mechanizm "podnoszenia" deklaracji zmiennych i funkcji
- 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. 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: