Pętla for

for – podstawy

Pętla for wykonuje swój blok kodu dla każdej wartości, po której przechodzi. Schemat jest prosty: for (zmienna in coś_do_przejścia). Przy każdym obrocie zmienna przyjmuje kolejną wartość.

for (i in 1..5) {
    println("Iteracja numer $i")
}
// Iteracja numer 1
// Iteracja numer 2
// ... aż do 5

Iteracja po zakresie

Najczęściej for przechodzi po zakresie. Wykorzystasz tu wszystko, co znasz z poprzedniej lekcji: .., until, downTo i step.

// w górę
for (i in 1..5) print("$i ")          // 1 2 3 4 5
println()

// bez ostatniej wartości
for (i in 1 until 5) print("$i ")      // 1 2 3 4
println()

// w dół
for (i in 5 downTo 1) print("$i ")     // 5 4 3 2 1
println()

// co drugą wartość
for (i in 0..10 step 2) print("$i ")   // 0 2 4 6 8 10

Iteracja po kolekcji

Pętla for potrafi przejść po liście wartości – po kolei oddaje każdy jej element. Listy poznasz dokładnie w osobnym bloku; tutaj wystarczy wiedzieć, że listOf(...) tworzy listę, a for ją obchodzi.

val owoce = listOf("jabłko", "banan", "gruszka")

for (owoc in owoce) {
    println("Owoc: $owoc")
}
// Owoc: jabłko
// Owoc: banan
// Owoc: gruszka

Iteracja po znakach tekstu

Tekst (String) też da się obejść pętlą for – wtedy zmienna przyjmuje kolejno każdy znak (typ Char).

val slowo = "Kotlin"

for (znak in slowo) {
    print("$znak ")   // K o t l i n
}

To przydaje się np. do liczenia konkretnych znaków – choć i tu można połączyć wiedzę z poprzednich lekcji:

val tekst = "programowanie"
var samogloski = 0

for (znak in tekst) {
    if (znak in "aeiouyąęó") {
        samogloski++
    }
}
println("Liczba samogłosek: $samogloski")

Indeks i wartość: withIndex()

Czasem podczas przechodzenia po liście potrzebujesz jednocześnie pozycji (indeksu) i wartości. Pomaga w tym withIndex() – w nawiasie pętli podajesz wtedy dwie nazwy w klamrach (indeks, wartość).

val owoce = listOf("jabłko", "banan", "gruszka")

for ((indeks, owoc) in owoce.withIndex()) {
    println("$indeks: $owoc")
}
// 0: jabłko
// 1: banan
// 2: gruszka

Pętle zagnieżdżone

Pętlę można umieścić wewnątrz innej pętli. Dla każdego obrotu pętli zewnętrznej pętla wewnętrzna wykonuje się w całości. Klasyczny przykład to tabliczka mnożenia.

for (i in 1..3) {
    for (j in 1..3) {
        print("${i * j}\t")   // \t to tabulator
    }
    println()                  // nowa linia po każdym wierszu
}
// 1  2  3
// 2  4  6
// 3  6  9

Częste błędy

❌ Błąd 1: próba „klasycznej” pętli

for (i = 0; i < 10; i++) {
    // Błąd! taka pętla
    // for nie istnieje
    // w Kotlinie
}

for (i in 0 until 10) {
    println(i)
}

❌ Błąd 2: zakres malejący przez ..

for (i in 10..1) {
    print(i)
}
// nic! 10..1 jest pusty

for (i in 10 downTo 1) {
    print("$i ")
}
// 10 9 8 ... 1

❌ Błąd 3: zmiana zmiennej pętli w środku

for (i in 1..5) {
    i = i + 1
    // Błąd! zmiennej pętli
    // nie można nadpisać
}

for (i in 1..5 step 2) {
    println(i)
}
// 1 3 5

❌ Błąd 4: indeks poza zakresem listy

for (i in 0..lista.size) {
    println(lista[i])
}
// Błąd! ostatni indeks
// to size - 1

for (i in lista.indices) {
    println(lista[i])
}
// poprawne indeksy

Podsumowanie

• Schemat pętli: for (zmienna in coś_do_przejścia) { ... }.
• W Kotlinie nie ma klasycznej pętli ze licznikiem – przechodzimy po zakresie, kolekcji lub tekście.
• Po zakresie: 1..10, until, downTo, step – tak jak poznałeś w lekcji o zakresach.
• Po kolekcji: for (element in lista); po tekście: for (znak in tekst).
• withIndex() daje naraz indeks i wartość: for ((i, v) in lista.withIndex()).
• Pętle można zagnieżdżać; liczba obrotów się mnoży.
• Zmiennej pętli nie można nadpisywać; do listy po indeksie używaj indices.

Zadania do wykonania

Zadania z wczytywaniem uruchamiaj w IntelliJ IDEA; pozostałe w Kotlin Playground.