Loop, While, For | Rust

• Loop, While, For | Rust

---

No Rust, loop é a forma mais básica de repetição infinita.

Exemplo:

fn main() {
    loop {
        println!("Rodando para sempre...");
    }
}

Esse código nunca termina sozinho.

Para que serve

loop é usado quando você quer:

• repetir indefinidamente
• sair manualmente com break
• controlar a repetição de forma mais flexível

Saindo do loop com break

fn main() {
    let mut contador = 0;

    loop {
        contador += 1;
        println!("contador: {}", contador);

        if contador == 5 {
            break;
        }
    }
}

Aqui o loop para quando contador == 5.

Retornando valor com break

No Rust, loop pode retornar um valor:

fn main() {
    let mut contador = 0;

    let resultado = loop {
        contador += 1;

        if contador == 10 {
            break contador * 2;
        }
    };

    println!("resultado: {}", resultado);
}

Saída:

resultado: 20

Isso é uma diferença importante: o loop pode ser usado como uma expressão.

Diferença entre loop, while e for

loop

Repete para sempre, até você usar break.

loop {
    println!("infinito");
}

while

Repete enquanto uma condição for verdadeira.

let mut x = 0;

while x < 5 {
    println!("{}", x);
    x += 1;
}

for

Usado para iterar sobre intervalos, arrays, vetores, coleções etc.

for i in 1..=5 {
    println!("{}", i);
}

Quando usar loop

Use loop quando:

• você não sabe exatamente quantas vezes vai repetir
• quer montar um ciclo manual
• precisa retornar valor com break
• quer fazer menu interativo, leitura contínua, retry, game loop etc.

Exemplo com leitura:

fn main() {
    loop {
        let mut entrada = String::new();

        println!("Digite 'sair' para encerrar:");
        std::io::stdin()
            .read_line(&mut entrada)
            .expect("Erro ao ler");

        if entrada.trim() == "sair" {
            break;
        }

        println!("Você digitou: {}", entrada.trim());
    }
}

Resumo

• loop cria um laço infinito
• break encerra o laço
• break valor pode retornar um valor do loop
• é a estrutura de repetição mais “bruta” e flexível do Rust

---