Klasa 1 · rozdział 5

Pętle w JavaScript

Warunek wybiera jedną gałąź. Pętla powtarza blok: znany zakres, „dopóki”, albo ciało przynajmniej raz. Tablice i for…of — później.

Po tym rozdziale powinieneś umieć

  • powiedzieć, co jest jednym obrotem, a co całą pętlą;
  • rozpisać trzy części for i sprawdzić pierwszy oraz ostatni numer;
  • stosować while i do…while;
  • sterować obiegiem: break, continue oraz zagnieżdżać pętlę z if.

1. Po co jest pętla

Bez pętli ten sam wypis piszesz tyle razy, ile chcesz linii. Przy trzech zdaniach da się. Przy pięćdziesięciu — nie: łatwo pominąć linię, a zmiana tekstu oznacza poprawkę w każdym miejscu.

console.log("Punkt 1");
console.log("Punkt 2");
console.log("Punkt 3");

Pętla zapisuje przepis na jeden obrót i mówi, kiedy przestać. Komputer sam powtarza blok w klamrach { }. To ciało pętli. Jeden obrót = jedno wykonanie ciała. Cała pętla = wszystkie obroty, aż warunek przestanie być prawdziwy.

Trzy rzeczy, które musisz ustalić Od czego zaczynasz (licznik).
Kiedy pętla jeszcze trwa (warunek).
Co zmienia się po każdym obrocie (inaczej warunek nigdy nie zgaśnie).

2. Pętla for

for bierzesz, gdy znasz zakres: „od 1 do 5”, „dziesięć razy”, „numery po kolei”. W nawiasie są trzy części, oddzielone średnikami. Kolejność jest stała.

for (let i = 1; i <= 5; i++) {
    console.log(`Punkt ${i}`);
}
Część W przykładzie Kiedy się wykonuje
Start let i = 1 Raz, przed pierwszym obrotem
Warunek i <= 5 Przed każdym obrotem. Fałsz = koniec pętli
Zmiana i++ Po ciele, zanim warunek sprawdzi się znowu

i to licznik. Nazwa jest umowna (często i, przy drugiej pętli j). let w nawiasie znaczy: ta nazwa żyje tylko w pętli, nie zostaje na cały skrypt. i++ to skrót na i = i + 1 — po obrocie licznik rośnie o 1.

Ślad tego przykładu. W konsoli zobaczysz pięć linii:

Krok i Warunek i <= 5 Co widać w konsoli
start1prawdaPunkt 1
po i++2prawdaPunkt 2
po i++3prawdaPunkt 3
po i++4prawdaPunkt 4
po i++5prawdaPunkt 5
po i++6fałsz — stopnic więcej

Ostatni wypisany numer to 5, bo warunek sprawdza się przed ciałem. Gdy i dojdzie do 6, ciało już się nie wykona.

O jeden za mało albo za dużo

<= i < dają inny ostatni numer. Przy starcie od 1:

Warunek Wypisane numery Ile obrotów
i <= 5 1, 2, 3, 4, 5 5
i < 5 1, 2, 3, 4 4
i <= 4 przy starcie i = 0 0, 1, 2, 3, 4 5

Po napisaniu pętli sprawdź w konsoli pierwszą i ostatnią linię. Jeśli ostatnia jest o jeden za duża albo za mała, poprawiasz znak w warunku, nie ciało.

Odliczanie w dół

Start od większej liczby, warunek „jeszcze nie zeszliśmy poniżej 1”, zmiana i-- (czyli i = i - 1).

for (let i = 5; i >= 1; i--) {
    console.log(i);
}

Konsola: 5, potem 4, 3, 2, 1. Przy i równym 0 warunek i >= 1 jest fałszywy.

Gdy zapomnisz zmiany

for (let i = 1; i <= 5; ) {
    console.log(i);
}

i zostaje 1 na zawsze, warunek zostaje prawdziwy, pętla nie staje. Karta przeglądarki może przestać odpowiadać. W DevTools (F12) użyj przycisku stop albo zamknij kartę, dopisz i++ i odśwież stronę.

To samo zdanie wiele razy Licznik nie musi trafić do tekstu. Pętla poniżej wypisze „Cześć” dokładnie trzy razy — i tylko liczy obroty.
for (let i = 1; i <= 3; i++) {
    console.log("Cześć");
}

3. while i do…while

W for start, warunek i zmiana stoją razem w nawiasie. W while zostaje sam warunek. Start piszesz przed pętlą, zmianę — w ciele. Pomysł jest ten sam: powtarzaj, dopóki warunek jest prawdziwy.

while

Warunek jest sprawdzany przed każdym obrotem. Gdy od razu jest fałszywy, ciało nie wykona się ani razu.

let n = 3;
while (n > 0) {
    console.log(n);
    n--;
}
Przed obrotem n > 0 Konsola n po n--
3prawda32
2prawda21
1prawda10
0fałsz — stop——

n-- musi być w ciele. Bez niego n zostaje 3, warunek zostaje prawdziwy i pętla nie staje — tak samo jak for bez i++.

let n = 0;
while (n > 0) {
    console.log("to się nie wypisze");
    n--;
}

Start od 0: warunek pada od razu, w konsoli pusto. Zero obrotów jest poprawnym wynikiem.

To samo odliczanie przez for i przez while

for

for (let i = 1; i <= 3; i++) {
    console.log(i);
}

while

let i = 1;
while (i <= 3) {
    console.log(i);
    i++;
}

Obie wersje wypiszą 1, 2, 3. Przy znanym zakresie for jest krótszy, bo start i i++ widać w jednej linii. while bierzesz, gdy koniec nie jest „do numeru N” — na przykład „dopóki użytkownik nie wpisze stop” albo „dopóki liczba jest dodatnia”.

do…while

Ciało jest nad warunkiem. Najpierw obrót, dopiero potem pytanie „czy jeszcze raz?”. Dlatego blok wykona się co najmniej raz, nawet gdy warunek jest fałszywy.

let n = 0;
do {
    console.log("raz");
} while (n > 0);

Przy n = 0 zwykłe while milczy. do…while wypisze „raz”, sprawdzi warunek, zobaczy fałsz i stanie. Średnik po while (…) jest tu potrzebny — w samym while średnika po nawiasie nie stawiasz.

Typowe użycie: zapytaj, a potem powtórz, jeśli odpowiedź jest zła. Pierwsze pytanie musi paść, zanim w ogóle wiadomo, czy powtarzać.

let wpis;
do {
    wpis = prompt("Wpisz liczbę");
} while (wpis !== null && Number.isNaN(Number(wpis)));

Pętla staje, gdy użytkownik kliknie Anuluj (null) albo wpisze coś, co Number zamienia na liczbę. Litery dają NaN, więc pytanie wraca.

Kiedy która pętla Znany zakres, licznik widać od razu → for. „Dopóki coś zachodzi”, a start i zmianę piszesz sam → while. Najpierw zrób, potem sprawdź (pytanie, które musi paść raz) → do…while.

4. break, continue, zagnieżdżenia

Zwykła pętla wykonuje całe ciało przy każdym obrocie, aż padnie warunek w nawiasie. Dwa słowa pozwalają przerwać ten schemat w środku ciała.

  • break — wyjdź z pętli od razu. Dalsze obroty się nie wykonają. To samo słowo kończy case w switch.
  • continue — porzuć resztę tego obrotu i przejdź do następnego (w for najpierw wykona się i++, potem znowu warunek).

continue osobno

for (let i = 1; i <= 5; i++) {
    if (i % 2 === 0) {
        continue;
    }
    console.log(i);
}

Parzyste (i % 2 === 0) wpadają w continue, więc console.log pod spodem się nie wykona. W konsoli zostają 1, 3, 5. Pętla i tak dochodzi do 5 — continue nie kończy całości.

break osobno

for (let i = 1; i <= 10; i++) {
    if (i > 3) {
        break;
    }
    console.log(i);
}

Wypisze 1, 2, 3. Przy i = 4 warunek i > 3 jest prawdziwy, break wychodzi z pętli, choć w nawiasie for stoi jeszcze i <= 10.

Oba w jednej pętli

Kolejność if ma znaczenie. Tu najpierw odsiew parzystych, potem przerwanie powyżej 7.

for (let i = 1; i <= 10; i++) {
    if (i % 2 === 0) {
        continue;
    }
    if (i > 7) {
        break;
    }
    console.log(i);
}

1 wypisane, 2 pominięte, 3 wypisane, 4 pominięte, 5 wypisane, 6 pominięte, 7 wypisane. Ósemka jest parzysta, więc continue — do break w tym obrocie nie dochodzisz. Dziewiątka jest nieparzysta i większa niż 7, więc break. W konsoli: 1, 3, 5, 7.

if w pętli

Najczęstsze zagnieżdżenie na start: w każdym obrocie sprawdzasz warunek i coś robisz tylko czasem. Pętla i tak idzie dalej — w odróżnieniu od break.

for (let i = 1; i <= 6; i++) {
    if (i % 2 === 0) {
        console.log(i + " parzysta");
    }
}

Pętla w pętli

Zewnętrzna pętla robi wiersze. Przy każdym wierszu wewnętrzna przechodzi wszystkie kolumny od początku. Przy trzech wierszach i trzech kolumnach ciało wewnętrzne wykona się 3 × 3 = 9 razy.

for (let w = 1; w <= 3; w++) {
    let wiersz = "";
    for (let k = 1; k <= 3; k++) {
        wiersz += (w * k) + " ";
    }
    console.log(wiersz);
}

Pierwszy wiersz (w = 1): wewnętrzna pętla dokleja 1*1, 1*2, 1*3, więc w konsoli 1 2 3. Drugi wiersz startuje od pustego wiersz i dokleja 2 4 6. let wiersz jest w zewnętrznej pętli, więc każdy wiersz buduje się od nowa.

break wychodzi tylko z pętli, w której stoi — z wewnętrznej, nie z obu naraz. Sumę albo licznik (zmienna przed pętlą, dopisywana w obrocie) dokładniej omawia następny rozdział.

Ćwiczenia do samodzielnego wykonania

Własny folder, HTML + skrypt.js, "use strict";, wynik w konsoli.

Ćwiczenie 1. Lista for łatwe

Pętlą for wypisz w konsoli liczby od 1 do 10. Sprawdź, czy pierwsza linia to 1, a ostatnia 10. Potem ten sam zakres w dół (10 … 1) — tu zmiana to i--, warunek i >= 1.

Ćwiczenie 2. while w dół łatwe

n z kodu (np. 5). while: wypisuj kolejne liczby w dół aż do 1. Gdy n jest 0, pętla ma się nie wykonać.

Ćwiczenie 3. do…while i prompt średnie

Pytaj o liczbę, aż Number(wpis) nie będzie NaN (i nie Anuluj). Użyj do…while. Na końcu wypisz wczytaną liczbę.

Ćwiczenie 4. continue i break średnie

Pętla for od 1 do 20. Pomiń liczby podzielne przez 3 (continue). Zatrzymaj się, gdy napotkasz liczbę większą niż 14 (break). W komentarzu: które wartości faktycznie poszły do konsoli.

Ćwiczenie 5. Pętla + warunek trudne

Wczytaj n (dodatnia liczba). Wypisz wszystkie parzyste od 2 do n włącznie. Osobno: zlicz, ile ich było (zmienna-licznik przed pętlą). Zero parzystych też ma działać (np. n = 1).

Licznik let ile = 0; przed pętlą, w obrocie ile++ przy parzystej. Po pętli szablon z ile.

Sprawdź się

1. Która pętla wykona ciało przynajmniej raz?
2. for (let i = 1; i <= 5; i++) — środkowa część to:
3. continue w pętli:
4. break w pętli:
5. while (n > 0) przy n = 0 wykona się:
6. for (let i = 1; i < 5; i++) wypisze numery:

Wymagania na ocenę

Ocena wyższa zawiera wymagania na oceny niższe.

Ocena Uczeń
2 Stosuje pętlę for o znanym zakresie według wzoru.
3 Stosuje while w zadaniu typowym. Łączy pętlę z prostym if.
4 Stosuje do…while, break lub continue. Zagnieżdża pętlę i warunek.
5 Dobiera pętlę (for vs while) do zadania. Testuje zero obrotów. Zlicza albo sumuje w pętli.
6 Uzasadnia liczbę obrotów i wybór pętli. Porównuje zagnieżdżenie z spłaszczonym warunkiem bez zmiany działania.

Lista „już umiem”