Pular para o conteúdo
Rust em Português

Lição 7 de 18 · 20 min

Controle de fluxo

Use if como expressão, repita código com loop, while e for, devolva valor no break e controle laços aninhados com rótulos.

Ao terminar, você vai saber:

  • Tomar decisões com if, else if e else
  • Usar if como expressão para escolher um valor
  • Repetir código com loop, while e for
  • Devolver um valor de um loop com break
  • Percorrer ranges e listas, e usar rótulos em laços aninhados

Até aqui seus programas rodavam de cima para baixo, linha por linha. Controle de fluxo é o que permite decidir (fazer isto ou aquilo) e repetir (fazer de novo). No Rust, as ferramentas são if, loop, while e for.

if, else if e else

fn main() {
    let temperatura = 31;

    if temperatura >= 30 {
        println!("Dia de praia.");
    } else if temperatura >= 20 {
        println!("Dia agradável.");
    } else {
        println!("Pega o casaco.");
    }
}

Diferenças para outras linguagens:

  • Não precisa de parênteses em volta da condição.
  • As chaves são obrigatórias, mesmo com uma linha só.
  • A condição tem que ser bool. O Rust não trata número como verdadeiro ou falso.

Veja o que acontece se você tentar o atalho de outras linguagens:

fn main() {
    let mensagens_novas = 3;

    if mensagens_novas {
        println!("Você tem mensagens.");
    }
}
error[E0308]: mismatched types
  |
4 |     if mensagens_novas {
  |        ^^^^^^^^^^^^^^^ expected `bool`, found integer

O certo é ser explícito: if mensagens_novas > 0. Parece chato, mas evita uma classe inteira de bugs.

if como expressão

Lembra da lição de funções? Blocos são expressões e produzem valor. O if também. Então dá para usar o if do lado direito de um let:

fn main() {
    let idade = 15;
    let ingresso = if idade < 12 { 0.0 } else if idade < 18 { 15.0 } else { 30.0 };

    println!("Ingresso: R$ {ingresso:.2}");
}

Isso substitui o operador ternário (condicao ? a : b) de outras linguagens. E tem uma vantagem: a variável ingresso continua imutável, porque recebe o valor uma vez só.

A regra é que todos os braços devolvam o mesmo tipo. Se um braço devolve número e outro texto, o compilador recusa, já que a variável precisa ter um tipo só.

loop: repetir até mandar parar

O loop repete para sempre, até encontrar um break:

fn main() {
    let mut tentativas = 0;

    loop {
        tentativas += 1;
        println!("Tentativa {tentativas}");

        if tentativas == 3 {
            break;
        }
    }

    println!("Parou depois de {tentativas} tentativas.");
}

Devolvendo valor com break

O loop também é uma expressão. O valor que você coloca depois do break vira o valor do loop. Útil quando você repete algo até achar uma resposta:

fn main() {
    let mut valor = 1;

    // Dobra o valor até passar de 1000
    let resultado = loop {
        valor *= 2;
        if valor > 1000 {
            break valor;
        }
    };

    println!("Primeiro valor acima de 1000: {resultado}");
}

Saída:

Primeiro valor acima de 1000: 1024

continue

O continue pula o resto da volta atual e vai direto para a próxima. Vale em qualquer tipo de laço.

while: repetir enquanto for verdade

O while confere a condição antes de cada volta:

fn main() {
    let mut contagem = 5;

    while contagem > 0 {
        println!("{contagem}...");
        contagem -= 1;
    }

    println!("Feliz Ano Novo!");
}

Use while quando você não sabe quantas voltas vai dar, mas sabe a condição de parada.

for: percorrer uma sequência

O for é o laço mais usado no Rust. Ele percorre os itens de algo, um por um.

Com ranges

Um range é uma sequência de números. 1..5 vai de 1 a 4 (o 5 fica de fora). 1..=5 vai de 1 a 5 (o = inclui o último).

fn main() {
    for numero in 1..=10 {
        println!("7 x {numero} = {}", 7 * numero);
    }
}

Para contar de trás para frente, use .rev():

fn main() {
    for segundo in (1..=3).rev() {
        println!("{segundo}");
    }
    println!("Decolar!");
}

Com listas e .iter()

Para percorrer um array, use .iter(). Ele cria um iterador, algo que entrega os itens um de cada vez:

fn main() {
    let compras = ["arroz", "feijão", "farinha", "café"];

    for item in compras.iter() {
        println!("- {item}");
    }
}

Se também precisar da posição, use .iter().enumerate(), que entrega pares (posição, item):

fn main() {
    let classificacao = ["Flamengo", "Palmeiras", "Botafogo"];

    for (posicao, time) in classificacao.iter().enumerate() {
        println!("{}º lugar: {time}", posicao + 1);
    }
}

Por que não usar while com índice, como em C? Dá, mas o for é mais seguro e mais rápido: ele nunca acessa uma posição que não existe, e o compilador consegue otimizar melhor.

Para somar uma lista, o for resolve bem:

fn main() {
    let gastos = [45.0, 12.5, 89.9, 30.0];
    let mut total = 0.0;

    for valor in gastos.iter() {
        total += valor;
    }

    println!("Gastos do mês: R$ {total:.2}");
}

Rótulos de loop

Quando um laço está dentro de outro, break e continue agem no laço mais de dentro. Para agir no de fora, dê um rótulo a ele. O rótulo começa com aspas simples:

fn main() {
    let andares = 3;
    let salas_por_andar = 4;
    let sala_procurada = (2, 3);

    'predio: for andar in 1..=andares {
        for sala in 1..=salas_por_andar {
            println!("Olhando andar {andar}, sala {sala}");

            if (andar, sala) == sala_procurada {
                println!("Achei!");
                break 'predio; // sai dos dois laços de uma vez
            }
        }
    }
}

Sem o rótulo, o break sairia só do laço das salas, e a busca continuaria no andar seguinte.

Qual laço usar?

  • for: para percorrer listas e ranges. É a escolha padrão.
  • while: para repetir enquanto uma condição for verdade.
  • loop: para repetir até um break, principalmente quando você quer devolver um valor.

Resumo

  • A condição do if precisa ser bool, sem parênteses e com chaves.
  • if é expressão: dá para usar no let, com todos os braços do mesmo tipo.
  • loop repete até um break, que pode devolver um valor.
  • while repete enquanto a condição for verdade.
  • for percorre ranges (1..5, 1..=5) e listas com .iter().
  • Rótulos como 'externo deixam o break e o continue agir no laço de fora.

Desafio

Escreva um programa que percorra os números de 1 a 30 e imprima "Pin" para múltiplos de 3, "Pan" para múltiplos de 5, "PinPan" para múltiplos de 3 e 5 e o próprio número nos outros casos. Use if como expressão para escolher o texto. Depois, com um loop e break com valor, descubra o primeiro número acima de 100 que é múltiplo de 7 e de 9 ao mesmo tempo.

Ver uma resposta
fn main() {
    for numero in 1..=30 {
        let texto = if numero % 15 == 0 {
            String::from("PinPan")
        } else if numero % 3 == 0 {
            String::from("Pin")
        } else if numero % 5 == 0 {
            String::from("Pan")
        } else {
            numero.to_string()
        };
        println!("{texto}");
    }

    let mut candidato = 101;
    let achado = loop {
        if candidato % 7 == 0 && candidato % 9 == 0 {
            break candidato;
        }
        candidato += 1;
    };

    println!("Primeiro múltiplo de 7 e 9 acima de 100: {achado}");
}

Todos os braços do if devolvem String, por isso o número vira texto com to_string(). O resultado do loop é 126.

Salvo só neste navegador.