Kurs JavaScript i TypeScript · Moduł 1: Podstawy JavaScript
Pętle i iteracje
W tej lekcji11
W Parku Jurajskim rutynowe zadania muszą być wykonywane regularnie i powtarzalnie: sprawdzanie ogrodzenia każdego wybiegu co godzinę, monitorowanie wszystkich kamer bezpieczeństwa, aktualizacja statusu zdrowia każdego dinozaura. Ręczne wykonywanie tych czynności byłoby żmudne i podatne na błędy.
Podobnie w JavaScript, pętle pozwalają na automatyczne i efektywne wykonywanie powtarzalnych operacji. Zamiast pisać ten sam kod wielokrotnie, możemy użyć pętli do wykonania go dla wielu elementów lub określoną liczbę razy.
Pętla for
Pętla for jest jedną z najpopularniejszych pętli w JavaScript. Składa się z trzech części: inicjalizacji, warunku i wyrażenia aktualizującego.
// Podstawowa struktura pętli for
for (inicjalizacja; warunek; aktualizacja) {
// Blok kodu do wykonania
}W praktyce w Parku Jurajskim, możemy użyć pętli for do automatyzacji rutynowych zadań:
// Sprawdzanie stanu zdrowia każdego dinozaura w sektorze
let dinozaury = ["Tyranozaur", "Velociraptor", "Triceratops", "Stegozaur", "Brachiozaur"];
for (let i = 0; i < dinozaury.length; i++) {
console.log(`Sprawdzanie stanu zdrowia: ${dinozaury[i]}`);
// Kod sprawdzający stan zdrowia konkretnego dinozaura...
}
// Wynik:
// Sprawdzanie stanu zdrowia: Tyranozaur
// Sprawdzanie stanu zdrowia: Velociraptor
// Sprawdzanie stanu zdrowia: Triceratops
// Sprawdzanie stanu zdrowia: Stegozaur
// Sprawdzanie stanu zdrowia: Brachiozaur
// Monitoring kamer bezpieczeństwa
for (let kamera = 1; kamera <= 10; kamera++) {
console.log(`Sprawdzanie kamery #${kamera}`);
// Kod analizujący obraz z kamery...
}
// Generowanie raportu dziennego za ostatnie 7 dni
for (let dzień = 1; dzień <= 7; dzień++) {
console.log(`Generowanie raportu za dzień #${dzień}`);
// Kod generujący raport za konkretny dzień...
}Pętla for ma trzy główne elementy:
- Inicjalizacja (np.
let i = 0) - wykonywana raz, przed rozpoczęciem pętli - Warunek (np.
i < dinozaury.length) - sprawdzany przed każdą iteracją; pętla kończy się, gdy warunek zwracafalse - Aktualizacja (np.
i++) - wykonywana po każdej iteracji
Pętla for...of
Pętla for...of to nowsza i bardziej elegancka forma pętli, która pozwala na iterację po elementach kolekcji (tablice, stringi, mapy, sety, itp.) bez potrzeby śledzenia indeksów.
// Struktura pętli for...of
for (let element of kolekcja) {
// Blok kodu do wykonania dla każdego elementu
}Pętla for...of jest szczególnie przydatna, gdy interesują nas same elementy, a nie ich indeksy:
// Sprawdzanie stanu zdrowia każdego dinozaura przy użyciu for...of
let dinozaury = ["Tyranozaur", "Velociraptor", "Triceratops", "Stegozaur", "Brachiozaur"];
for (let dinozaur of dinozaury) {
console.log(`Sprawdzanie stanu zdrowia: ${dinozaur}`);
// Kod sprawdzający stan zdrowia konkretnego dinozaura...
}
// Sprawdzanie poziomu zapasów różnych rodzajów pokarmu
let zapasyPokarmu = {
mięso: 500, // kg
liście: 1200, // kg
owoce: 300, // kg
ryby: 200 // kg
};
// Uwaga: for...of nie działa bezpośrednio na obiektach, ale możemy użyć Object.entries()
for (let [rodzajPokarmu, ilość] of Object.entries(zapasyPokarmu)) {
console.log(`Pokarm: ${rodzajPokarmu}, Ilość: ${ilość} kg`);
if (ilość < 300) {
console.log(`UWAGA: Niski poziom zapasów ${rodzajPokarmu}! Należy uzupełnić.`);
}
}
// Wynik:
// Pokarm: mięso, Ilość: 500 kg
// Pokarm: liście, Ilość: 1200 kg
// Pokarm: owoce, Ilość: 300 kg
// Pokarm: ryby, Ilość: 200 kg
// UWAGA: Niski poziom zapasów ryby! Należy uzupełnić.Pętla for...in
Pętla for...in jest przeznaczona do iteracji po właściwościach obiektu. Zwraca nazwy kluczy (właściwości) obiektu.
// Struktura pętli for...in
for (let klucz in obiekt) {
// Blok kodu do wykonania dla każdego klucza
}Przykład użycia w Parku Jurajskim:
// Analiza danych o dinozaurze
let tyranozaur = {
gatunek: "Tyrannosaurus Rex",
wiek: 12,
waga: 8000, // kg
długość: 12, // m
wysokość: 5.6, // m
prędkość: 27, // km/h
poziomAgresji: "Bardzo wysoki"
};
// Wypisanie wszystkich informacji o dinozaurze
for (let cecha in tyranozaur) {
console.log(`${cecha}: ${tyranozaur[cecha]}`);
}
// Sprawdzenie, które cechy dinozaura przekraczają wartości bezpieczeństwa
let limityBezpieczeństwa = {
waga: 5000, // kg
prędkość: 25, // km/h
poziomAgresji: "Wysoki"
};
for (let parametr in limityBezpieczeństwa) {
if (tyranozaur[parametr] > limityBezpieczeństwa[parametr] ||
(parametr === "poziomAgresji" && tyranozaur[parametr] === "Bardzo wysoki")) {
console.log(`UWAGA: Parametr ${parametr} przekracza wartości bezpieczeństwa!`);
}
}
// Wynik:
// UWAGA: Parametr waga przekracza wartości bezpieczeństwa!
// UWAGA: Parametr prędkość przekracza wartości bezpieczeństwa!
// UWAGA: Parametr poziomAgresji przekracza wartości bezpieczeństwa!Ważna uwaga: Pętla for...in iteruje po wszystkich właściwościach obiektu, w tym dziedziczonych. Jeśli chcemy ograniczyć się tylko do własnych właściwości obiektu, możemy użyć metody hasOwnProperty():
for (let cecha in tyranozaur) {
if (tyranozaur.hasOwnProperty(cecha)) {
console.log(`${cecha}: ${tyranozaur[cecha]}`);
}
}Różnice między for...of i for...in
Ważne jest, aby zrozumieć różnicę między tymi dwoma typami pętli:
- for...of - iteruje po wartościach elementów kolekcji (tablice, stringi, itp.)
- for...in - iteruje po nazwach właściwości (kluczach) obiektu
let dinosaurNames = ["T-Rex", "Raptor", "Triceratops"];
// for...of (wartości)
for (let name of dinosaurNames) {
console.log(name); // "T-Rex", "Raptor", "Triceratops"
}
// for...in (indeksy/klucze)
for (let index in dinosaurNames) {
console.log(index); // "0", "1", "2"
console.log(dinosaurNames[index]); // "T-Rex", "Raptor", "Triceratops"
}Pętla while
Pętla while wykonuje blok kodu, dopóki określony warunek jest prawdziwy. W przeciwieństwie do pętli for, pętla while ma tylko warunek.
// Struktura pętli while
while (warunek) {
// Blok kodu do wykonania
}W Parku Jurajskim, pętla while może być używana do procesów, które nie mają z góry określonej liczby iteracji:
// System monitorowania temperatury inkubatora jaj
let temperatura = 37.5; // stopnie Celsjusza
let docelowaTemperatura = 38.2;
let przyrostTemperatury = 0.1;
console.log("Rozpoczęcie procesu podgrzewania inkubatora...");
while (temperatura < docelowaTemperatura) {
console.log(`Aktualna temperatura: ${temperatura.toFixed(1)}°C`);
temperatura += przyrostTemperatury;
// Kod do symulacji upływu czasu...
}
console.log(`Osiągnięto docelową temperaturę: ${temperatura.toFixed(1)}°C`);
// System monitorowania poziomu zasilania
let poziomZasilania = 100; // procent
let krytycznyPoziom = 20;
let spadekZasilania = 5;
console.log("Monitorowanie poziomu zasilania po awarii głównego generatora...");
while (poziomZasilania > krytycznyPoziom) {
console.log(`Poziom zasilania: ${poziomZasilania}%`);
poziomZasilania -= spadekZasilania;
// Kod do symulacji upływu czasu...
}
console.log(`ALARM! Krytyczny poziom zasilania: ${poziomZasilania}%`);
console.log("Uruchamianie protokołu awaryjnego...");Pętla do...while
Pętla do...while jest podobna do pętli while, ale z jedną kluczową różnicą: blok kodu jest zawsze wykonywany przynajmniej raz, zanim warunek zostanie sprawdzony.
// Struktura pętli do...while
do {
// Blok kodu do wykonania
} while (warunek);Ta pętla jest przydatna, gdy chcemy, aby kod został wykonany co najmniej raz, niezależnie od warunku:
// Procedura uruchamiania systemu bezpieczeństwa
let systemSprawny = false;
let liczbaProb = 0;
let maksymalnaLiczbaProb = 3;
do {
console.log("Próba uruchomienia systemu bezpieczeństwa...");
liczbaProb++;
// Symulacja losowości działania systemu
systemSprawny = Math.random() > 0.5; // 50% szans na sukces
if (systemSprawny) {
console.log("System bezpieczeństwa uruchomiony pomyślnie!");
} else {
console.log(`Uruchomienie systemu nie powiodło się. Próba ${liczbaProb} z ${maksymalnaLiczbaProb}.`);
}
} while (!systemSprawny && liczbaProb < maksymalnaLiczbaProb);
if (!systemSprawny) {
console.log("KRYTYCZNY BŁĄD: System bezpieczeństwa nie może zostać uruchomiony. Konieczna interwencja techniczna!");
}
// Procedura ewakuacji
let pozostaliLudzie = 100;
do {
console.log(`Pozostało ${pozostaliLudzie} osób do ewakuacji.`);
// Symulacja ewakuacji - każda iteracja to jedna grupa ewakuowanych
let wielkośćGrupy = Math.floor(Math.random() * 20) + 10; // 10-29 osób
pozostaliLudzie -= wielkośćGrupy;
// Upewniamy się, że nie otrzymamy ujemnej liczby
if (pozostaliLudzie < 0) pozostaliLudzie = 0;
console.log(`Ewakuowano grupę ${wielkośćGrupy} osób.`);
} while (pozostaliLudzie > 0);
console.log("Wszyscy zostali ewakuowani. Obiekt jest pusty.");Przerwanie i kontynuacja pętli: break i continue
JavaScript oferuje dwie specjalne instrukcje do kontrolowania przebiegu pętli:
- break - natychmiast przerywa pętlę i wychodzi z niej
- continue - przerywa bieżącą iterację i przechodzi do następnej
Przykład użycia break
// Poszukiwanie uszkodzonej sekcji ogrodzenia
let sekcjeOgrodzenia = [
{ id: 1, status: "sprawna" },
{ id: 2, status: "sprawna" },
{ id: 3, status: "uszkodzona" },
{ id: 4, status: "sprawna" },
{ id: 5, status: "sprawna" }
];
let znalezionoUszkodzenie = false;
for (let i = 0; i < sekcjeOgrodzenia.length; i++) {
console.log(`Sprawdzanie sekcji #${sekcjeOgrodzenia[i].id}...`);
if (sekcjeOgrodzenia[i].status === "uszkodzona") {
console.log(`UWAGA! Znaleziono uszkodzoną sekcję #${sekcjeOgrodzenia[i].id}!`);
console.log("Wysyłanie zespołu naprawczego...");
znalezionoUszkodzenie = true;
break; // Przerywamy pętlę, gdy znaleźliśmy uszkodzenie
}
}
if (!znalezionoUszkodzenie) {
console.log("Wszystkie sekcje ogrodzenia są sprawne.");
}
// Wynik:
// Sprawdzanie sekcji #1...
// Sprawdzanie sekcji #2...
// Sprawdzanie sekcji #3...
// UWAGA! Znaleziono uszkodzoną sekcję #3!
// Wysyłanie zespołu naprawczego...Przykład użycia continue
// Sprawdzanie stanu zdrowia dinozaurów, pomijając te, które są w trakcie badań
let dinozaury = [
{ nazwa: "Rex", gatunek: "Tyranozaur", dostępny: true },
{ nazwa: "Blue", gatunek: "Velociraptor", dostępny: false }, // W trakcie badań
{ nazwa: "Spike", gatunek: "Stegozaur", dostępny: true },
{ nazwa: "Cera", gatunek: "Triceratops", dostępny: false }, // W trakcie badań
{ nazwa: "Bronty", gatunek: "Brontozaur", dostępny: true }
];
console.log("Rozpoczęcie codziennych badań kontrolnych...");
for (let i = 0; i < dinozaury.length; i++) {
if (!dinozaury[i].dostępny) {
console.log(`Dinozaur ${dinozaury[i].nazwa} (${dinozaury[i].gatunek}) jest już w trakcie badań. Pomijam.`);
continue; // Przechodzimy do następnej iteracji, pomijając resztę kodu w tej iteracji
}
console.log(`Przeprowadzanie badania dinozaura ${dinozaury[i].nazwa} (${dinozaury[i].gatunek})...`);
console.log("Badanie zakończone. Stan zdrowia: dobry.");
}
// Wynik:
// Rozpoczęcie codziennych badań kontrolnych...
// Przeprowadzanie badania dinozaura Rex (Tyranozaur)...
// Badanie zakończone. Stan zdrowia: dobry.
// Dinozaur Blue (Velociraptor) jest już w trakcie badań. Pomijam.
// Przeprowadzanie badania dinozaura Spike (Stegozaur)...
// Badanie zakończone. Stan zdrowia: dobry.
// Dinozaur Cera (Triceratops) jest już w trakcie badań. Pomijam.
// Przeprowadzanie badania dinozaura Bronty (Brontozaur)...
// Badanie zakończone. Stan zdrowia: dobry.Pętle zagnieżdżone
Pętle mogą być także zagnieżdżane jedna w drugiej, co jest przydatne przy pracy z danymi wielowymiarowymi:
// Sprawdzanie stanu ogrodzeń we wszystkich sektorach Parku Jurajskiego
// Tablica dwuwymiarowa: [sektor][sekcja_ogrodzenia]
let statusOgrodzeń = [
// Sektor 1
[
{ id: "1A", stan: "sprawne" },
{ id: "1B", stan: "sprawne" },
{ id: "1C", stan: "uszkodzone" }
],
// Sektor 2
[
{ id: "2A", stan: "sprawne" },
{ id: "2B", stan: "sprawne" },
{ id: "2C", stan: "sprawne" }
],
// Sektor 3
[
{ id: "3A", stan: "sprawne" },
{ id: "3B", stan: "uszkodzone" },
{ id: "3C", stan: "sprawne" }
]
];
console.log("Rozpoczęcie inspekcji ogrodzeń we wszystkich sektorach...");
for (let i = 0; i < statusOgrodzeń.length; i++) {
console.log(`\nInspekcja sektora ${i + 1}:`);
let wszystkieSprawne = true;
for (let j = 0; j < statusOgrodzeń[i].length; j++) {
let sekcja = statusOgrodzeń[i][j];
console.log(` Sekcja ${sekcja.id}: ${sekcja.stan}`);
if (sekcja.stan === "uszkodzone") {
wszystkieSprawne = false;
console.log(` UWAGA: Sekcja ${sekcja.id} wymaga naprawy!`);
}
}
if (wszystkieSprawne) {
console.log(` Wszystkie ogrodzenia w sektorze ${i + 1} są sprawne.`);
} else {
console.log(` W sektorze ${i + 1} wykryto uszkodzone ogrodzenia.`);
}
}
// Wynik:
// Rozpoczęcie inspekcji ogrodzeń we wszystkich sektorach...
//
// Inspekcja sektora 1:
// Sekcja 1A: sprawne
// Sekcja 1B: sprawne
// Sekcja 1C: uszkodzone
// UWAGA: Sekcja 1C wymaga naprawy!
// W sektorze 1 wykryto uszkodzone ogrodzenia.
//
// Inspekcja sektora 2:
// Sekcja 2A: sprawne
// Sekcja 2B: sprawne
// Sekcja 2C: sprawne
// Wszystkie ogrodzenia w sektorze 2 są sprawne.
//
// Inspekcja sektora 3:
// Sekcja 3A: sprawne
// Sekcja 3B: uszkodzone
// UWAGA: Sekcja 3B wymaga naprawy!
// Sekcja 3C: sprawne
// W sektorze 3 wykryto uszkodzone ogrodzenia.Pętle nieskończone i jak ich unikać
Pętla nieskończona to pętla, która nigdy się nie kończy, ponieważ jej warunek zakończenia nigdy nie jest spełniony. W Parku Jurajskim, pętla nieskończona w systemie bezpieczeństwa mogłaby prowadzić do katastrofy, podobnie jak w programowaniu może powodować zawieszenie aplikacji lub zużycie wszystkich zasobów.
Oto przykład pętli nieskończonej:
// UWAGA: To jest pętla nieskończona! Nie uruchamiaj tego kodu!
while (true) {
console.log("To się będzie wyświetlać w nieskończoność!");
}
// Inny przykład pętli nieskończonej:
for (let i = 0; i >= 0; i++) {
console.log(i); // To będzie liczyć w nieskończoność!
}Aby uniknąć pętli nieskończonych:
- Upewnij się, że warunek zakończenia pętli jest osiągalny
- Zawsze aktualizuj zmienne używane w warunku pętli
- Rozważ dodanie dodatkowego warunku wyjścia (np. licznik iteracji)
- Używaj instrukcji
breakjako zabezpieczenia
// Bezpieczniejsza wersja z limitem iteracji
let maksymalnaLiczbaIteracji = 1000;
let licznikIteracji = 0;
// Przykład bezpiecznego monitorowania
while (monitorujPark()) {
// Kod monitorowania parku...
licznikIteracji++;
if (licznikIteracji >= maksymalnaLiczbaIteracji) {
console.log("Osiągnięto maksymalną liczbę iteracji. Przerwanie pętli.");
break;
}
}
function monitorujPark() {
// Logika monitorowania...
return true; // Normalnie zwracałoby true lub false w zależności od warunków
}Praktyki i wzorce związane z pętlami
1. Wybór odpowiedniej pętli
- for - gdy znasz dokładną liczbę iteracji lub pracujesz z indeksami
- for...of - gdy chcesz iterować po elementach kolekcji (tablice, stringi)
- for...in - gdy chcesz iterować po właściwościach obiektu
- while - gdy warunek zakończenia zależy od zewnętrznych czynników
- do...while - gdy chcesz, aby kod wykonał się przynajmniej raz
2. Optymalizacja pętli
// Nieoptymalna pętla - długość tablicy jest przeliczana w każdej iteracji
for (let i = 0; i < dinozaury.length; i++) {
// Kod...
}
// Zoptymalizowana pętla - długość tablicy jest przeliczana tylko raz
for (let i = 0, len = dinozaury.length; i < len; i++) {
// Kod...
}3. Wczesne wyjście z pętli
// Wczesne wyjście z pętli po znalezieniu pierwszego pasującego elementu
function znajdźDinozaura(nazwa) {
for (let dinozaur of bazaDinozaurów) {
if (dinozaur.nazwa === nazwa) {
return dinozaur; // Natychmiastowy zwrot po znalezieniu
}
}
return null; // Brak pasującego dinozaura
}4. Unikanie modyfikacji licznika pętli wewnątrz pętli
// Niebezpieczne - modyfikowanie licznika wewnątrz pętli
for (let i = 0; i < 10; i++) {
console.log(i);
if (i === 5) {
i = 8; // Przeskakujemy część iteracji - to może być mylące
}
}
// Lepsze podejście - użyj instrukcji continue lub break
for (let i = 0; i < 10; i++) {
if (i > 5 && i < 9) {
continue; // Przeskakujemy iteracje 6, 7, 8
}
console.log(i);
}Podsumowanie
Pętle w JavaScript, podobnie jak rutynowe procedury w Parku Jurajskim, pozwalają na efektywne wykonywanie powtarzalnych operacji:
- for - do iteracji przez określoną liczbę powtórzeń
- for...of - do iteracji po elementach kolekcji
- for...in - do iteracji po właściwościach obiektu
- while - do wykonywania kodu, dopóki warunek jest prawdziwy
- do...while - do wykonywania kodu przynajmniej raz, a następnie dopóki warunek jest prawdziwy
Dodatkowo, instrukcje kontrolne:
- break - przerywa całą pętlę
- continue - przechodzi do następnej iteracji
Wybór odpowiedniej pętli zależy od konkretnego przypadku użycia, ale ogólnie należy dążyć do:
- Używania najprostszej pętli odpowiedniej dla danego zadania
- Optymalizowania pętli, szczególnie dla dużych kolekcji danych
- Unikania pętli nieskończonych
- Używania czytelnych nazw zmiennych i jasnej struktury kodu
W następnej lekcji przyjrzymy się funkcjom, które pozwalają na organizowanie kodu w wielokrotnie używalne bloki - niezbędne dla utrzymania porządku w tak złożonym systemie jak Park Jurajski.
Kod do tej lekcji: index.js
// Pętle w JavaScript - automatyzacja zadań w parku
// for, while, for...of, for...in
// === Pętla for ===
console.log("=== Pętla for: Patrol zagród ===");
let zagrody = ["T-Rex", "Raptor", "Triceratops", "Brachio", "Stego"];
for (let i = 0; i < zagrody.length; i++) {
console.log("Zagroda " + (i + 1) + ": " + zagrody[i] + " - OK");
}
// === Pętla for...of ===
console.log("\n=== for...of: Karmienie ===");
for (const dino of zagrody) {
console.log("Karmienie: " + dino);
}
// === Pętla for...in (dla obiektów) ===
console.log("\n=== for...in: Dane dinozaura ===");
const trex = {
nazwa: "Tyrannosaurus Rex",
waga: 7000,
dieta: "mięsożerca",
sektor: "A"
};
for (const klucz in trex) {
console.log(klucz + ": " + trex[klucz]);
}
// === Pętla while ===
console.log("\n=== while: Skanowanie próbek ===");
let probki = 5;
while (probki > 0) {
console.log("Skanowanie próbki nr " + probki + "...");
probki--;
}
console.log("Skanowanie zakończone!");
// === do...while ===
console.log("\n=== do...while: Weryfikacja ===");
let proby = 0;
do {
proby++;
console.log("Próba weryfikacji nr " + proby);
} while (proby < 3);
// === break i continue ===
console.log("\n=== break i continue ===");
let dane = [10, 25, 0, 42, 15, -1, 30];
for (const wartosc of dane) {
if (wartosc === -1) {
console.log("Znaleziono wartość -1, przerywam!");
break;
}
if (wartosc === 0) {
console.log("Pomijam wartość 0...");
continue;
}
console.log("Przetwarzam: " + wartosc);
}
// Twoje zadanie:
// 1. Użyj pętli for do wypisania liczb od 1 do 10
// 2. Użyj while do odliczania od 10 do 0
// 3. Użyj for...of do przejścia po tablicy
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óre trzy elementy zawiera nagłówek pętli for?
Zadania praktyczne w grze
- Edytor kodu
Zapisz w tablicy enclosures nazwy co najmniej trzech wybiegów. Za pomocą pętli wyświetl w konsoli komunikat z nazwą każdego wybiegu, np. 'Sprawdzam: Wybieg T-Rexa'.
- Układanie w poziomie
Ułóż elementy pętli for...of:
- Edytor kodu
Zapisz w tablicy dnaSamples nazwy gatunków z próbek DNA, np. ['Velociraptor', 'Triceratops', 'Velociraptor']. Przejdź po tablicy pętlą, policz próbki gatunku 'Velociraptor' i wyświetl wynik w konsoli.
- Układanie w poziomie
Ułóż elementy pętli for w prawidłowej kolejności: