Controle de Fluxo em Rust

Quando estamos aprendendo uma nova linguagem, uma das primeiras perguntas práticas é: como faço o programa tomar decisões e repetir tarefas?
Em Rust, isso é feito por meio do controle de fluxo: estruturas como if, loop, while e for. Elas determinam qual trecho do código será executado e quantas vezes.

Se você já programou em outras linguagens, os conceitos vão soar familiares. A diferença é que Rust foi projetado para ser seguro, previsível e expressivo, o que traz alguns detalhes interessantes (e úteis!) que você vai ver agora.

1. Tomando decisões com if

O if em Rust funciona de forma parecida com outras linguagens: ele executa um bloco de código se uma condição for verdadeira. A grande diferença é que a condição precisa ser obrigatoriamente um bool (true ou false): nada de usar números como em C.

Exemplo 1: Verificando acesso por idade

fn main() {
    let idade = 17;

    if idade >= 18 {
        println!("Acesso liberado.");
    } else {
        println!("Acesso negado.");
    }
}

Explicação passo a passo

• let idade = 17;
  Criamos uma variável com a idade da pessoa.
• if idade >= 18 {
  Verificamos se a idade é maior ou igual a 18.
  Essa expressão gera um true ou false.
• println!("Acesso liberado.");
  Só será executado se a condição for verdadeira.
• else { println!("Acesso negado."); }
  Executado quando a condição for falsa.

Resultado esperado:
Como 17 < 18, o programa imprime Acesso negado.

if também pode virar uma expressão

Em Rust, if não é só uma estrutura de decisão. Ele também pode retornar um valor.

fn main() {
    let temperatura = 30;

    let clima = if temperatura > 25 {
        "Quente"
    } else {
        "Agradável"
    };

    println!("Hoje o clima está: {}", clima);
}

Aqui, o if escolhe qual texto será armazenado em clima. Isso deixa o código mais limpo e expressivo.

2. Repetindo tarefas com laços (loops)

Rust oferece três principais formas de repetição:

• loop - repete para sempre (até você mandar parar)
• while - repete enquanto uma condição for verdadeira
• for - percorre coleções ou intervalos

3. loop: repetição infinita (com saída controlada)

Use loop quando você ainda não sabe quantas vezes vai repetir.

fn main() {
    let mut contador = 0;

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

        if contador == 3 {
            break;
        }
    }

    println!("Loop finalizado!");
}

Explicação:

• let mut contador = 0;
  Criamos um contador mutável (ele vai mudar).
• loop { ... }
  Inicia um laço que, por padrão, nunca para sozinho.
• contador += 1;
  Incrementa o contador a cada repetição.
• if contador == 3 { break; }
  Quando o contador chega em 3, usamos break para sair do loop.

Saída esperada:

Contador: 1
Contador: 2
Contador: 3
Loop finalizado!

4. while: repetir enquanto for verdadeiro

O while é ideal quando você tem uma condição clara de parada desde o início.

fn main() {
    let mut energia = 5;

    while energia > 0 {
        println!("Energia restante: {}", energia);
        energia -= 1;
    }

    println!("Bateria esgotada!");
}

• O laço continua enquanto energia > 0.
• Assim que a condição se torna falsa, o while termina.

5. for: o jeito mais seguro de repetir

O for é o laço mais usado em Rust, porque é simples e evita vários erros comuns.

fn main() {
    for numero in 1..=5 {
        println!("Número atual: {}", numero);
    }
}

• 1..=5 cria um intervalo de 1 até 5 (inclusive).
• O for percorre esse intervalo automaticamente.
• Não precisa de contador manual.

Saída:

Número atual: 1
Número atual: 2
Número atual: 3
Número atual: 4
Número atual: 5

Em Rust, essas estruturas também ajudam no desempenho (sem sobrecargas ocultas) e na segurança (menos estados inválidos, menos bugs difíceis de rastrear).

• Use for sempre que possível. É mais seguro.
• Use loop quando a saída depende de lógica interna.
• Use if como expressão quando quiser escrever código mais limpo.

Conclusão

O controle de fluxo em Rust é simples, seguro e poderoso.
Com if, loop, while e for, você já consegue criar programas que tomam decisões, repetem tarefas e reagem a diferentes situações do mundo real.