Fluxo de Controle

Rust fornece if/else, três formas de loop (loop, while, for) e match exaustivo. Loops e branches podem produzir valores quando usados como expressões.

Receita

fn sum_evens(nums: &[i32]) -> i32 {
    let mut total = 0;
    for &n in nums {
        if n % 2 == 0 {
            total += n;
        }
    }
    total
}
 
fn first_negative(nums: &[i32]) -> Option<i32> {
    for &n in nums {
        if n < 0 {
            return Some(n);
        }
    }
    None
}

Quando usar: Qualquer ramificação ou iteração. Prefira for em vez de while com índice manual ao iterar coleções.

Exemplo de Trabalho

fn find_pair(target: i32, nums: &[i32]) -> Option<(usize, usize)> {
    'outer: for i in 0..nums.len() {
        for j in (i + 1)..nums.len() {
            if nums[i] + nums[j] == target {
                break 'outer (i, j);
            }
        }
    }
}
 
fn retry<F: FnMut() -> bool>(mut f: F, max: u32) -> bool {
    let mut attempts = 0;
    loop {
        if f() {
            break true;
        }
        attempts += 1;
        if attempts >= max {
            break false;
        }
    }
}
 
fn main() {
    let nums = [2, 7, 11, 15];
    println!("{:?}", find_pair(9, &nums));
    println!("{}", retry(|| false, 3));
}

O que isso demonstra:

• break 'outer rotulado sai de loops aninhados com um valor de tupla
• loop com break condicional implementa lógica de retentativa
• Intervalo 0..nums.len() para acesso baseado em índice quando necessário
• Option para resultados ausentes em vez de valores sentinela

Mergulho Profundo

Formas de Loop

let squares: Vec<i32> = (0..5).map(|n| n * n).collect();

Exaustividade do match

enum Color { Red, Green, Blue }
 
fn hex(c: Color) -> &'static str {
    match c {
        Color::Red => "#f00",
        Color::Green => "#0f0",
        Color::Blue => "#00f",
    }
}

Erros de compilador se uma variante estiver faltando. Use _ apenas quando você intencionalmente captura os casos restantes.

if let e while let

let Some(x) = opt else { return };
while let Some(line) = lines.next() {
    println!("{line}");
}

Correspondência parcial ergonômica sem match completo.

Armadilhas

• Condição if não é bool - if 1 { } falha. Correção: Use comparações explícitas.
• Intervalos off-by-one - 0..n exclui n. Correção: Use 0..=n para fim inclusivo quando necessário.
• Empréstimo em loops for - for item in &vec empresta; for item in vec move. Correção: Escolha iter(), iter_mut(), ou into_iter() deliberadamente.
• match não exaustivo - Adicionar variantes de enum quebra compilações. Correção: Trate como um recurso; atualize todos os match.
• Discrepância de tipo de valor break - Todos os break em um loop devem retornar o mesmo tipo. Correção: Anote ou unifique tipos.

Alternativas

FAQs

Relacionados

• Funções e Expressões - blocos orientados a expressão
• Correspondência de Padrões com match - padrões match detalhados
• if let, let else & while let - correspondências parciais
• Adaptadores de Iterador - transformações sem loop

Versões da Pilha: Esta página foi escrita para Rust 1.97.0 (edição 2024), Tokio 1.x, Axum 0.8, serde 1.0, sqlx 0.8, clap 4, e Polars 0.46+.