Kotlin Academy · Aula

break, continue e retornos rotulados

Controle o fluxo dos laços com break/continue e saia de laços aninhados usando rótulos.

Aula 4 de 413 etapas

break, continue e retornos rotulados é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.

Controle do fluxo dos laços

O Kotlin oferece break (sair do laço), continue (pular para a próxima iteração) e rótulos para sair de laços aninhados.

Noções básicas de break

break sai imediatamente do laço envolvente mais interno.

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

Noções básicas de continue

continue pula o restante da iteração atual e passa para a próxima.

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

Laços rotulados

Associe um rótulo a um laço com label@ e faça referência a ele usando break@label ou continue@label para controlar laços externos a partir de laços aninhados.

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

continue com um rótulo

Use continue@outer para pular para a próxima iteração de um laço externo.

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

Dentro de forEach e de outras funções inline, um return simples sai da função envolvente. Use return@forEach para sair apenas da lambda.

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

Retorno não local em lambdas

Se a lambda for inline, como forEach, um return simples sai da função envolvente inteira — o que às vezes surpreende.

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

Rótulo personalizado em uma lambda

Você pode rotular uma lambda explicitamente com name@ para deixar mais claro o destino do retorno.

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

break em while

break e continue funcionam da mesma forma em while e do-while.

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

Combinando rótulo e continue

Os rótulos e continue permitem pular iterações inteiras de algoritmos aninhados sem usar variáveis de controle.

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 não usar rótulos

Os rótulos acrescentam complexidade. Se você perceber que recorre a eles com frequência, considere extrair o laço interno para uma função que use um return comum.

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ção rápida

Como sair do laço externo a partir de um laço interno no Kotlin?

Recapitulação

break sai do laço mais interno; continue pula para a próxima iteração. Use label@ + break@label/continue@label para controlar laços aninhados. Em lambdas, prefira return@forEach a return para evitar saídas não locais.

Grátis para começar

Aprenda Kotlin com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos
51
Aulas
203

Perguntas Frequentes

A aula “break, continue e retornos rotulados” é grátis?

Sim — o texto completo de “break, continue e retornos rotulados” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.

O que vou aprender em “break, continue e retornos rotulados”?

Controle o fluxo dos laços com break/continue e saia de laços aninhados usando rótulos. Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Kotlin Academy?

Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “break, continue e retornos rotulados”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Kotlin Academy?

Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Laço for sobre intervalos e coleções
  2. while e do-while: quando usar cada um
  3. forEach, repeat e forEachIndexed
  4. break, continue e retornos rotulados
← Voltar para Kotlin Academy