0Pricing
Kotlin Academy · Lekcja

while i do-while: kiedy używać każdej z nich

Napisz pętle while i do-while oraz poznaj ich przypadki użycia.

while i do-while: kiedy używać każdej z nich to bezpłatna lekcja Kotlin Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Kotlin Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Dwa rodzaje pętli while

Kotlin oferuje zarówno while (z warunkiem sprawdzanym przed wykonaniem), jak i do-while (z warunkiem sprawdzanym po wykonaniu). Różnica polega na tym, że do-while zawsze wykonuje ciało pętli co najmniej raz.

Podstawowa pętla while

while sprawdza warunek przed każdą iteracją. Jeśli od początku jest on fałszywy, ciało pętli nie zostanie wykonane.

fun main() {
    var count = 0
    while (count < 3) {
        println("count = $count")
        count++
    }
}

Podstawowa pętla do-while

do-while wykonuje ciało pętli, a następnie sprawdza warunek. Ciało pętli zawsze wykona się co najmniej raz.

fun main() {
    var n = 10
    do {
        println("n = $n")
        n--
    } while (n > 7)
}

Odczyt do wartości wartownika

Pętle while są idealne, gdy nie wiadomo, ile iteracji będzie potrzebnych — na przykład podczas odczytu do napotkania wartości wartownika.

fun main() {
    val data = listOf(3, 7, 0, 9)
    var i = 0
    while (i < data.size && data[i] != 0) {
        println("got ${data[i]}")
        i++
    }
    println("stopped at index $i")
}

Wyszukiwanie na liście

while należy używać do wyszukiwania z wcześniejszym zakończeniem, gdy pętla powinna zatrzymać się natychmiast po spełnieniu warunku.

fun main() {
    val nums = listOf(2, 4, 7, 8, 10)
    var i = 0
    while (i < nums.size && nums[i] % 2 == 0) i++
    println("first odd at index $i = ${nums[i]}") // 2 = 7
}

do-while do sprawdzania danych wejściowych

do-while należy używać, gdy trzeba wykonać działanie (wyświetlić monit, odczytać dane lub podjąć próbę), zanim będzie można sprawdzić powodzenie.

fun main() {
    val validInputs = listOf("y", "n", "y")
    var idx = 0
    var input: String
    do {
        input = validInputs[idx++]
        println("user typed: $input")
    } while (input != "n" && idx < validInputs.size)
}

Licznik ze zmniejszaniem

Pętle while dobrze obsługują liczniki zmniejszane do zera.

fun main() {
    var lives = 3
    while (lives > 0) {
        println("Lives left: $lives")
        lives--
    }
    println("Game over")
}

Nieskończona pętla z break

W kodzie działającym podobnie do pętli zdarzeń należy użyć while (true) z break, gdy warunek wyjścia jest złożony.

fun main() {
    val items = listOf(1, 2, 3, -1, 4)
    var i = 0
    while (true) {
        if (i >= items.size || items[i] < 0) break
        println("ok: ${items[i]}")
        i++
    }
}

Porównanie while i for

Jeśli liczba iteracji jest znana z góry, należy preferować for. while należy używać, gdy liczba iteracji zależy od stanu w czasie działania programu.

fun main() {
    // for: known bounds
    for (i in 1..3) print("$i ")
    println()
    // while: state-driven
    var n = 1
    while (n <= 3) { print("$n "); n++ }
    println()
}

Pętla z dwiema zmiennymi

Pętle while mogą śledzić wiele zmiennych, co jest pomocne w algorytmach takich jak Fibonacci.

fun main() {
    var a = 0
    var b = 1
    while (b < 50) {
        print("$b ")
        val next = a + b
        a = b
        b = next
    }
    println() // 1 1 2 3 5 8 13 21 34
}

do-while zawsze wykonuje się raz

Nawet jeśli warunek od początku jest fałszywy, ciało do-while wykona się raz. Czasami jest to dokładnie pożądane zachowanie — innym razem jest to błąd.

fun main() {
    var x = 100
    do {
        println("x = $x") // prints once
        x--
    } while (x > 1000) // false immediately
}

Szybkie sprawdzenie

Która pętla gwarantuje wykonanie swojego ciała co najmniej raz, niezależnie od warunku?

Podsumowanie

while należy używać, gdy liczba iteracji zależy od warunku sprawdzanego w czasie działania programu. do-while należy używać, gdy ciało musi wykonać się co najmniej raz (np. podczas walidacji lub ponawiania próby). Jeśli liczba iteracji jest znana, należy preferować for.

Często zadawane pytania

Czy lekcja „while i do-while: kiedy używać każdej z nich” jest bezpłatna?

Tak — pełny tekst „while i do-while: kiedy używać każdej z nich” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Kotlin Academy, przejdź na CoddyKit PRO. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „while i do-while: kiedy używać każdej z nich”?

Napisz pętle while i do-while oraz poznaj ich przypadki użycia. Ćwiczysz Kotlin Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Kotlin Academy?

Nie wymagamy żadnego doświadczenia. Kotlin Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „while i do-while: kiedy używać każdej z nich”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Kotlin Academy?

Tak. Każda lekcja Kotlin Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Pętla for dla zakresów i kolekcji
  2. while i do-while: kiedy używać każdej z nich
  3. forEach, repeat i forEachIndexed
  4. break, continue i etykietowane return
← Powrót do Kotlin Academy