0Pricing
Kotlin Academy · Lezione

break, continue e return con etichetta

Controlli il flusso dei cicli con break e continue ed esca dai cicli annidati tramite le etichette.

break, continue e return con etichetta è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.

Controllo del flusso nei cicli

Kotlin supporta break (esce dal ciclo), continue (passa all'iterazione successiva) e le etichette per uscire dai cicli annidati.

Nozioni di base su break

break esce immediatamente dal ciclo più interno che lo contiene.

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

Nozioni di base su continue

continue salta il resto dell'iterazione corrente e passa a quella successiva.

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

Cicli con etichette

Assegni a un ciclo l'etichetta label@ e la richiami da break@label o continue@label per controllare i cicli esterni dall'interno di quelli annidati.

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

continue con un'etichetta

Utilizzi continue@outer per passare all'iterazione successiva di un ciclo esterno.

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

All'interno di forEach e di altre funzioni inline, un semplice return esce dalla funzione che le contiene. Utilizzi return@forEach per uscire solo dalla lambda.

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

return non locale nelle lambda

Se la lambda è inline, come forEach, un semplice return esce dall'intera funzione che la contiene, con un comportamento talvolta sorprendente.

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

Etichetta personalizzata per una lambda

Può assegnare esplicitamente un'etichetta a una lambda con name@ per indicare più chiaramente la destinazione del return.

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

break in while

break e continue funzionano allo stesso modo in while e do-while.

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

Combinare etichetta e continue

Le etichette e continue consentono di saltare intere iterazioni di algoritmi annidati senza usare variabili 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()
    }
}

Quando non usare le etichette

Le etichette aggiungono complessità. Se si accorge di ricorrervi spesso, consideri di estrarre il ciclo interno in una funzione con un normale 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))
}

Verifica rapida

Come si esce dal ciclo esterno dall'interno di un ciclo interno in Kotlin?

Riepilogo

break esce dal ciclo più interno; continue passa all'iterazione successiva. Utilizzi label@ + break@label/continue@label per il controllo dei cicli annidati. Nelle lambda, preferisca return@forEach a return per evitare uscite non locali.

Domande Frequenti

La lezione «break, continue e return con etichetta» è gratuita?

Sì — il testo completo di «break, continue e return con etichetta» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.

Cosa imparerò in «break, continue e return con etichetta»?

Controlli il flusso dei cicli con break e continue ed esca dai cicli annidati tramite le etichette. Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Kotlin Academy?

Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «break, continue e return con etichetta»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?

Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Ciclo for su intervalli e collezioni
  2. while e do-while: quando usare ciascuno
  3. forEach, repeat e forEachIndexed
  4. break, continue e return con etichetta
← Torna a Kotlin Academy