Break e Continue em Rust

O break e o continue permitem interromper um laço antes da hora, em vez de sempre rodá-lo até o fim. Eles funcionam do mesmo jeito nos três tipos de laço: loop, while e for.

break: sair do laço de vez

O break para o laço na mesma hora, e a execução pula para o que vier logo depois dele:

fn main() {
    for i in 1..=10 {
        if i == 5 {
            break;
        }
        println!("{i}");
    }
}

Saída:

1
2
3
4

▶ Experimente você mesmo

Mesmo com o intervalo indo até 10, o laço para no momento em que i chega a 5.

continue: pular para a próxima volta

O continue pula o resto da volta atual e vai direto para a próxima, em vez de parar o laço por completo:

fn main() {
    for i in 1..=10 {
        if i % 2 == 0 {
            continue; // pula os números pares
        }
        println!("{i}");
    }
}

Saída:

1
3
5
7
9

▶ Experimente você mesmo

Todos os números pares são pulados: o continue é acionado e o laço passa direto para o próximo valor de i, sem executar o println!.

Laços com rótulo

Quando você coloca um laço dentro de outro, um break/continue simples só afeta o laço mais interno. Se você precisa sair de um laço externo de dentro de um aninhado, dê um rótulo (label) ao laço externo, escrito como 'nome::

fn main() {
    'outer: for x in 1..=3 {
        for y in 1..=3 {
            if x * y > 4 {
                break 'outer;
            }
            println!("{x} x {y} = {}", x * y);
        }
    }
}

Saída:

1 x 1 = 1
1 x 2 = 2
1 x 3 = 3
2 x 1 = 2
2 x 2 = 4

▶ Experimente você mesmo

Sem o rótulo, o break pararia só o laço interno do y, e o x continuaria. O break 'outer; para os dois de uma vez. O continue 'outer; funciona do mesmo jeito, caso você queira pular para a próxima volta do laço externo em vez de parar tudo.

Nota

Você não vai precisar de laços com rótulo com frequência: a maior parte do código aninha laços em no máximo dois níveis, e muitas vezes nem precisa sair do laço externo. É bom reconhecer quando aparecer, mas não é algo para usar por padrão.

A armadilha do continue em laços while

Em um laço for, o próximo valor vem do intervalo automaticamente, então o continue é sempre seguro. Um laço while é diferente: é você quem atualiza o contador, normalmente no fim do corpo. Se o continue pular essa atualização, o contador nunca muda e o laço roda para sempre.

Esta versão tenta pular o 3, mas trava. Não a execute:

fn main() {
    let mut i = 0;
    while i < 5 {
        if i == 3 {
            continue; // ❌ volta para cima sem mudar o i
        }
        println!("{i}");
        i += 1;
    }
}

Quando i vale 3, o continue volta para a condição. O i continua valendo 3, então o continue é acionado de novo, e de novo, para sempre. A solução é atualizar o contador antes de qualquer coisa que possa dar continue:

fn main() {
    let mut i = 0;
    while i < 5 {
        i += 1; // atualize primeiro, para o continue não pular isso
        if i == 3 {
            continue;
        }
        println!("{i}");
    }
}

Saída:

1
2
4
5

▶ Experimente você mesmo

Mover o i += 1 para o topo desloca os números em um: este laço imprime de 1 a 5 em vez de 0 a 4, então ajuste o início ou a condição se precisar do intervalo antigo. Melhor ainda: se você só está contando, use um laço for sobre um intervalo, e o problema não tem como acontecer.

Prática

1. Pule os múltiplos de 3

Imprima os números de 1 a 10, mas pule todos os múltiplos de 3. Dica: um número é múltiplo de 3 quando n % 3 == 0. Use continue para pulá-lo.

Ver solução

fn main() {
    for n in 1..=10 {
        if n % 3 == 0 {
            continue;
        }
        println!("{n}");
    }
}

Saída:

1
2
4
5
7
8
10

▶ Experimente você mesmo

2. Encontre um par cujo produto seja 24

Use dois laços for aninhados, x e y, ambos sobre 1..=9. Encontre o primeiro par em que x * y == 24, imprima-o e pare os dois laços. Dica: coloque um rótulo no laço externo e use break 'outer;.

Ver solução

fn main() {
    'outer: for x in 1..=9 {
        for y in 1..=9 {
            if x * y == 24 {
                println!("Achei: {x} x {y} = 24");
                break 'outer;
            }
        }
    }
    println!("Busca encerrada");
}

Saída:

Achei: 3 x 8 = 24
Busca encerrada

▶ Experimente você mesmo

Experimente trocar break 'outer; por um break; simples. Agora só o laço interno para, então a busca continua e também imprime 4 x 6, 6 x 4 e 8 x 3.

Resumo

• O break sai do laço imediatamente.
• O continue pula o resto da iteração atual e passa para a próxima.
• Um rótulo ('outer:) permite que o break/continue atinja um laço externo de dentro de um aninhado.
• Em um laço while, atualize o contador antes de qualquer continue, ou o laço pode travar para sempre.

Teste o que aprendeu

Teste o que aprendeu

1. O que o continue faz dentro de um laço?

Para o laço por completo Pula o resto da iteração atual e passa para a próxima Recomeça o laço desde a primeira iteração

2. Como escrever um rótulo em um laço para que o break possa atingi-lo de dentro de um laço aninhado?

#outer @outer 'outer:

3. Um laço while com continue nunca termina. Qual é a causa mais provável?

O continue pula a linha que atualiza o contador O continue não pode ser usado em laços while O laço precisa de um rótulo

Pontuação: 0 / 3

Para saber mais

• Loop Labels to Disambiguate Between Multiple Loops — The Rust Book (em inglês): a introdução oficial aos rótulos, com um exemplo de contagem regressiva aninhada.
• Nesting and labels — Rust by Example (em inglês): um exemplo curto e executável de break 'outer e continue 'outer.
• Loop Labels — The Rust Reference (em inglês): as regras exatas de onde os rótulos podem ser usados.
• Expressões break — The Rust Reference (em inglês): como o break funciona, incluindo o break com um valor.
• Expressões continue — The Rust Reference (em inglês): o que o continue faz em cada tipo de laço.