Kotlin Academy · Lekcja

break, continue i etykietowane return

Steruj przebiegiem pętli za pomocą break i continue oraz opuszczaj zagnieżdżone pętle przy użyciu etykiet.

Lekcja 4 z 413 kroki

break, continue i etykietowane return to bezpłatna lekcja Kotlin Academy na CoddyKit. To lekcja 4 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.

Sterowanie przebiegiem pętli

Kotlin obsługuje break (wyjście z pętli), continue (przejście do następnej iteracji) oraz etykiety umożliwiające wyjście z zagnieżdżonych pętli.

Podstawy break

break natychmiast kończy wykonanie najbardziej wewnętrznej otaczającej pętli.

fun main() {
    for (i in 1..10) {
        if (i == 5) break
        print("$i ")
    }
    println() // 1 2 3 4
}

Podstawy continue

continue pomija resztę bieżącej iteracji i przechodzi do następnej.

fun main() {
    for (i in 1..10) {
        if (i % 2 == 0) continue
        print("$i ")
    }
    println() // 1 3 5 7 9
}

Pętle z etykietami

Pętlę można oznaczyć za pomocą label@, a następnie odwołać się do niej przez break@label lub continue@label, aby sterować zewnętrznymi pętlami z wnętrza zagnieżdżonych.

fun main() {
    outer@ for (i in 1..3) {
        for (j in 1..3) {
            if (i == 2 && j == 2) break@outer
            println("$i,$j")
        }
    }
}

continue z etykietą

Za pomocą continue@outer można przejść do następnej iteracji zewnętrznej pętli.

fun main() {
    outer@ for (i in 1..3) {
        for (j in 1..3) {
            if (j == 2) continue@outer
            println("i=$i j=$j")
        }
    }
}

return@lambda

Wewnątrz forEach i innych funkcji inline zwykły return kończy działanie funkcji zewnętrznej. Aby zakończyć tylko lambdę, należy użyć return@forEach.

fun main() {
    listOf(1, 2, 3, 4, 5).forEach {
        if (it == 3) return@forEach
        println(it)
    }
    println("Done")
}

Nielokalny return w lambdach

Jeśli lambda jest funkcją inline (tak jak forEach), zwykły return kończy całą funkcję zewnętrzną — co czasami może zaskakiwać.

fun process() {
    listOf(1, 2, 3).forEach {
        if (it == 2) return // exits process()
        println(it)
    }
    println("never printed")
}
fun main() { process() }

Własna etykieta lambdy

Lambdę można jawnie oznaczyć etykietą za pomocą name@, aby wyraźniej wskazać cel instrukcji return.

fun main() {
    listOf(1, 2, 3, 4).forEach loop@{
        if (it == 3) return@loop
        println(it)
    }
}

break w while

break i continue działają tak samo w while i do-while.

fun main() {
    var i = 0
    while (true) {
        if (i >= 3) break
        println("i = $i")
        i++
    }
}

Łączenie etykiety i continue

Etykiety i continue pozwalają pomijać całe iteracje zagnieżdżonych algorytmów bez używania zmiennych-flag.

fun main() {
    val grid = listOf(listOf(1,2,0), listOf(3,4,5), listOf(0,6,7))
    rows@ for (row in grid) {
        for (cell in row) {
            if (cell == 0) continue@rows
            print("$cell ")
        }
        println()
    }
}

Kiedy nie używać etykiet

Etykiety zwiększają złożoność kodu. Jeśli często trzeba po nie sięgać, warto rozważyć przeniesienie wewnętrznej pętli do funkcji ze zwykłym return.

fun firstMatch(grid: List<List<Int>>, target: Int): Pair<Int,Int>? {
    for (r in grid.indices) for (c in grid[r].indices) {
        if (grid[r][c] == target) return r to c
    }
    return null
}
fun main() {
    val g = listOf(listOf(1,2),listOf(3,4))
    println(firstMatch(g, 3))
}

Szybkie sprawdzenie

Jak wyjść z zewnętrznej pętli z wnętrza pętli wewnętrznej w Kotlinie?

Podsumowanie

break kończy najbardziej wewnętrzną pętlę, a continue przechodzi do następnej iteracji. Do sterowania zagnieżdżonymi pętlami należy używać label@ wraz z break@label/continue@label. W lambdach należy preferować return@forEach zamiast return, aby uniknąć nielokalnego wyjścia.

Bezpłatny start

Ucz się Kotlin dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy
51
Lekcje
203

Często zadawane pytania

Czy lekcja „break, continue i etykietowane return” jest bezpłatna?

Tak — pełny tekst „break, continue i etykietowane return” 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 „break, continue i etykietowane return”?

Steruj przebiegiem pętli za pomocą break i continue oraz opuszczaj zagnieżdżone pętle przy użyciu etykiet. Ć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 4 z 4.

Ile czasu zajmuje lekcja „break, continue i etykietowane return”?

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