Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Controle de fluxo

A capacidade de executar um trecho de código dependendo de uma condição ser true e a capacidade de executar um trecho de código repetidamente enquanto uma condição for true são blocos básicos de construção na maioria das linguagens de programação. As construções mais comuns que permitem controlar o fluxo de execução do código Rust são as expressões if e os loops.

Expressões if

Uma expressão if permite que você ramifique seu código dependendo de condições. Você fornece uma condição e, então, afirma: “Se esta condição for atendida, execute este bloco de código. Se a condição não for atendida, não execute este bloco de código.”

Crie um novo projeto chamado branches na sua pasta projects para explorar a expressão if. No arquivo src/main.rs, digite o seguinte:

Nome do arquivo: src/main.rs

fn main() {
    let number = 3;

    if number < 5 {
        println!("condition was true");
    } else {
        println!("condition was false");
    }
}

Todas as expressões if começam com a palavra-chave if, seguida de uma condição. Neste caso, a condição verifica se a variável number tem um valor menor que 5. Colocamos o bloco de código a ser executado se a condição for true logo após a condição, entre chaves. Os blocos de código associados às condições das expressões if às vezes são chamados de braços, assim como os braços das expressões match que discutimos na seção “Comparando o palpite com o número secreto” do Capítulo 2.

Opcionalmente, também podemos incluir uma expressão else, como fizemos aqui, para dar ao programa um bloco de código alternativo a ser executado caso a condição seja avaliada como false. Se você não fornecer uma expressão else e a condição for false, o programa simplesmente pula o bloco if e segue para o próximo trecho de código.

Experimente executar este código; você deve ver a seguinte saída:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/branches`
condition was true

Vamos tentar mudar o valor de number para um valor que torne a condição false, para ver o que acontece:

fn main() {
    let number = 7;

    if number < 5 {
        println!("condition was true");
    } else {
        println!("condition was false");
    }
}

Execute o programa novamente e observe a saída:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/branches`
condition was false

Vale notar também que a condição neste código precisa ser um bool. Se a condição não for um bool, vamos ter um erro. Por exemplo, experimente executar o código a seguir:

Nome do arquivo: src/main.rs

fn main() {
    let number = 3;

    if number {
        println!("number was three");
    }
}

Desta vez, a condição do if é avaliada como o valor 3, e o Rust gera um erro:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
error[E0308]: mismatched types
 --> src/main.rs:4:8
  |
4 |     if number {
  |        ^^^^^^ expected `bool`, found integer

For more information about this error, try `rustc --explain E0308`.
error: could not compile `branches` (bin "branches") due to 1 previous error

O erro indica que o Rust esperava um bool, mas recebeu um inteiro. Diferentemente de linguagens como Ruby e JavaScript, o Rust não tenta converter automaticamente tipos que não são booleanos para booleano. Você precisa ser explícito e sempre fornecer um booleano como condição do if. Se quisermos que o bloco if seja executado somente quando um número for diferente de 0, por exemplo, podemos alterar a expressão if para a seguinte:

Nome do arquivo: src/main.rs

fn main() {
    let number = 3;

    if number != 0 {
        println!("number was something other than zero");
    }
}

Executar este código vai imprimir number was something other than zero.

Tratando múltiplas condições com else if

Você pode usar múltiplas condições combinando if e else em uma expressão else if. Por exemplo:

Nome do arquivo: src/main.rs

fn main() {
    let number = 6;

    if number % 4 == 0 {
        println!("number is divisible by 4");
    } else if number % 3 == 0 {
        println!("number is divisible by 3");
    } else if number % 2 == 0 {
        println!("number is divisible by 2");
    } else {
        println!("number is not divisible by 4, 3, or 2");
    }
}

Este programa tem quatro caminhos possíveis a seguir. Depois de executá-lo, você deve ver a seguinte saída:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/branches`
number is divisible by 3

Quando este programa é executado, ele verifica cada expressão if em sequência e executa o primeiro bloco cuja condição é avaliada como true. Repare que, embora 6 seja divisível por 2, não vemos a saída number is divisible by 2, nem o texto number is not divisible by 4, 3, or 2 do bloco else. Isso acontece porque o Rust só executa o bloco da primeira condição true e, assim que encontra uma, nem chega a verificar as demais.

Usar muitas expressões else if pode deixar seu código poluído, então, se você tiver mais de uma, talvez queira refatorar o código. O Capítulo 6 descreve uma construção de ramificação poderosa do Rust chamada match, feita para esses casos.

Usando if em uma instrução let

Como if é uma expressão, podemos usá-lo do lado direito de uma instrução let para atribuir o resultado a uma variável, como na Listagem 3-2.

Nome do arquivo: src/main.rs
fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };

    println!("The value of number is: {number}");
}
Listagem 3-2: Atribuindo o resultado de uma expressão if a uma variável

A variável number vai ser vinculada a um valor com base no resultado da expressão if. Execute este código para ver o que acontece:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/branches`
The value of number is: 5

Lembre-se de que blocos de código são avaliados para a última expressão que contêm, e que números sozinhos também são expressões. Neste caso, o valor da expressão if inteira depende de qual bloco de código é executado. Isso significa que os valores que podem resultar de cada braço do if precisam ser do mesmo tipo; na Listagem 3-2, os resultados tanto do braço if quanto do braço else eram inteiros i32. Se os tipos forem incompatíveis, como no exemplo a seguir, teremos um erro:

Nome do arquivo: src/main.rs

fn main() {
    let condition = true;

    let number = if condition { 5 } else { "six" };

    println!("The value of number is: {number}");
}

Quando tentamos compilar este código, recebemos um erro. Os braços if e else têm tipos de valor incompatíveis, e o Rust indica exatamente onde está o problema no programa:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
error[E0308]: `if` and `else` have incompatible types
 --> src/main.rs:4:44
  |
4 |     let number = if condition { 5 } else { "six" };
  |                                 -          ^^^^^ expected integer, found `&str`
  |                                 |
  |                                 expected because of this

For more information about this error, try `rustc --explain E0308`.
error: could not compile `branches` (bin "branches") due to 1 previous error

A expressão no bloco if é avaliada como um inteiro, e a expressão no bloco else é avaliada como uma string. Isso não vai funcionar, porque variáveis precisam ter um único tipo, e o Rust precisa saber com certeza, em tempo de compilação, qual é o tipo da variável number. Conhecer o tipo de number permite que o compilador verifique se o tipo é válido em todos os lugares onde usamos number. O Rust não conseguiria fazer isso se o tipo de number fosse determinado somente em tempo de execução; o compilador ficaria mais complexo e ofereceria menos garantias sobre o código se precisasse acompanhar múltiplos tipos hipotéticos para qualquer variável.

Repetição com loops

Com frequência, é útil executar um bloco de código mais de uma vez. Para essa tarefa, o Rust oferece vários loops, que percorrem o código dentro do corpo do loop até o fim e, então, recomeçam imediatamente do início. Para experimentar com loops, vamos criar um novo projeto chamado loops.

O Rust tem três tipos de loops: loop, while e for. Vamos testar cada um.

Repetindo código com loop

A palavra-chave loop diz ao Rust para executar um bloco de código várias vezes seguidas, para sempre ou até que você mande explicitamente parar.

Como exemplo, altere o arquivo src/main.rs no seu diretório loops para ficar assim:

Nome do arquivo: src/main.rs

fn main() {
    loop {
        println!("again!");
    }
}

Quando executarmos este programa, veremos again! impresso repetidamente, sem parar, até que interrompamos o programa manualmente. A maioria dos terminais oferece o atalho de teclado ctrl-C para interromper um programa preso em um loop contínuo. Experimente:

$ cargo run
   Compiling loops v0.1.0 (file:///projects/loops)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.08s
     Running `target/debug/loops`
again!
again!
again!
again!
^Cagain!

O símbolo ^C representa o ponto em que você pressionou ctrl-C.

Você pode ou não ver a palavra again! impressa depois do ^C, dependendo de onde o código estava no loop quando recebeu o sinal de interrupção.

Felizmente, o Rust também oferece uma forma de sair de um loop por meio do código. Você pode colocar a palavra-chave break dentro do loop para dizer ao programa quando parar de executar o loop. Lembre-se de que fizemos isso no jogo de adivinhação, na seção “Saindo após um palpite correto” do Capítulo 2, para encerrar o programa quando o usuário ganhou o jogo ao adivinhar o número correto.

Também usamos continue no jogo de adivinhação, que, em um loop, diz ao programa para pular o restante do código nesta iteração do loop e ir para a próxima iteração.

Retornando valores de loops

Um dos usos de um loop é tentar novamente uma operação que você sabe que pode falhar, como verificar se uma thread terminou seu trabalho. Você também pode precisar passar o resultado dessa operação para fora do loop, para o restante do seu código. Para isso, você pode adicionar o valor que deseja retornar depois da expressão break que usa para parar o loop; esse valor será retornado para fora do loop, para que você possa usá-lo, como mostrado aqui:

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

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

    println!("The result is {result}");
}

Antes do loop, declaramos uma variável chamada counter e a inicializamos com 0. Em seguida, declaramos uma variável chamada result para guardar o valor retornado pelo loop. A cada iteração do loop, somamos 1 à variável counter e depois verificamos se counter é igual a 10. Quando for, usamos a palavra-chave break com o valor counter * 2. Depois do loop, usamos um ponto e vírgula para encerrar a instrução que atribui o valor a result. Por fim, imprimimos o valor de result, que neste caso é 20.

Você também pode usar return dentro de um loop. Enquanto break sai apenas do loop atual, return sempre sai da função atual.

Desambiguando com rótulos de loop

Se você tiver loops dentro de loops, break e continue se aplicam ao loop mais interno naquele ponto. Opcionalmente, você pode especificar um rótulo de loop em um loop, que depois pode ser usado com break ou continue para indicar que essas palavras-chave se aplicam ao loop rotulado em vez do loop mais interno. Rótulos de loop devem começar com uma aspa simples. Aqui está um exemplo com dois loops aninhados:

fn main() {
    let mut count = 0;
    'counting_up: loop {
        println!("count = {count}");
        let mut remaining = 10;

        loop {
            println!("remaining = {remaining}");
            if remaining == 9 {
                break;
            }
            if count == 2 {
                break 'counting_up;
            }
            remaining -= 1;
        }

        count += 1;
    }
    println!("End count = {count}");
}

O loop externo tem o rótulo 'counting_up e vai contar de 0 até 2. O loop interno, sem rótulo, conta de 10 até 9. O primeiro break que não especifica um rótulo vai sair apenas do loop interno. A instrução break 'counting_up; vai sair do loop externo. Este código imprime:

$ cargo run
   Compiling loops v0.1.0 (file:///projects/loops)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.58s
     Running `target/debug/loops`
count = 0
remaining = 10
remaining = 9
count = 1
remaining = 10
remaining = 9
count = 2
remaining = 10
End count = 2

Simplificando loops condicionais com while

Um programa frequentemente precisa avaliar uma condição dentro de um loop. Enquanto a condição for true, o loop roda. Quando a condição deixa de ser true, o programa chama break, parando o loop. É possível implementar um comportamento desses combinando loop, if, else e break; se quiser, você pode tentar isso agora em um programa. Porém, esse padrão é tão comum que o Rust tem uma construção de linguagem pronta para ele, chamada loop while. No Listagem 3-3, usamos while para fazer o programa dar três voltas, contando regressivamente a cada vez, e, depois do loop, imprimir uma mensagem e encerrar.

Nome do arquivo: src/main.rs
fn main() {
    let mut number = 3;

    while number != 0 {
        println!("{number}!");

        number -= 1;
    }

    println!("LIFTOFF!!!");
}
Listagem 3-3: Usando um loop while para executar código enquanto uma condição é avaliada como true

Essa construção elimina muito do aninhamento que seria necessário se você usasse loop, if, else e break, e ela é mais clara. Enquanto uma condição for avaliada como true, o código roda; caso contrário, o programa sai do loop.

Percorrendo uma coleção com for

Você pode optar por usar a construção while para percorrer os elementos de uma coleção, como um array. Por exemplo, o loop na Listagem 3-4 imprime cada elemento do array a.

Nome do arquivo: src/main.rs
fn main() {
    let a = [10, 20, 30, 40, 50];
    let mut index = 0;

    while index < 5 {
        println!("the value is: {}", a[index]);

        index += 1;
    }
}
Listagem 3-4: Percorrendo cada elemento de uma coleção usando um loop while

Aqui, o código percorre os elementos do array contando para cima. Ele começa no índice 0 e então repete até alcançar o último índice do array (isto é, quando index < 5 não for mais true). Executar este código vai imprimir cada elemento do array:

$ cargo run
   Compiling loops v0.1.0 (file:///projects/loops)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.32s
     Running `target/debug/loops`
the value is: 10
the value is: 20
the value is: 30
the value is: 40
the value is: 50

Todos os cinco valores do array aparecem no terminal, como esperado. Mesmo que index chegue a um valor de 5 em algum momento, o loop para de executar antes de tentar buscar um sexto valor no array.

No entanto, essa abordagem é propensa a erros; podemos fazer o programa entrar em pânico se o valor do índice ou a condição de teste estiverem incorretos. Por exemplo, se você mudasse a definição do array a para ter quatro elementos, mas esquecesse de atualizar a condição para while index < 4, o código entraria em pânico. Também é lento, porque o compilador adiciona código em tempo de execução para fazer, a cada iteração do loop, a verificação condicional de se o índice está dentro dos limites do array.

Como alternativa mais concisa, você pode usar um loop for e executar algum código para cada item de uma coleção. Um loop for se parece com o código da Listagem 3-5.

Nome do arquivo: src/main.rs
fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a {
        println!("the value is: {element}");
    }
}
Listagem 3-5: Percorrendo cada elemento de uma coleção usando um loop for

Quando executamos este código, vemos a mesma saída da Listagem 3-4. Mais importante ainda, aumentamos a segurança do código e eliminamos a chance de bugs que poderiam surgir por ir além do fim do array ou por não ir longe o suficiente e deixar de fora alguns itens. O código de máquina gerado por loops for também pode ser mais eficiente, porque o índice não precisa ser comparado com o tamanho do array a cada iteração.

Usando o loop for, você não precisaria se lembrar de alterar nenhum outro código se mudasse a quantidade de valores no array, como seria necessário com o método usado na Listagem 3-4.

A segurança e a concisão dos loops for fazem deles a construção de loop mais usada em Rust. Mesmo em situações em que você quer executar algum código um certo número de vezes, como no exemplo de contagem regressiva que usou um loop while no Listagem 3-3, a maioria dos Rustaceans usaria um loop for. A forma de fazer isso seria usar um Range, fornecido pela biblioteca padrão, que gera todos os números em sequência, começando em um número e terminando antes de outro.

Veja como ficaria a contagem regressiva usando um loop for e outro método que ainda não discutimos, rev, para inverter o intervalo:

Nome do arquivo: src/main.rs

fn main() {
    for number in (1..4).rev() {
        println!("{number}!");
    }
    println!("LIFTOFF!!!");
}

Este código ficou um pouco mais bonito, não ficou?

Resumo

Você chegou ao fim! Foi um capítulo extenso: você aprendeu sobre variáveis, tipos de dados escalares e compostos, funções, comentários, expressões if e loops! Para praticar os conceitos discutidos neste capítulo, tente criar programas que façam o seguinte:

  • Converter temperaturas entre Fahrenheit e Celsius.
  • Gerar o n-ésimo número de Fibonacci.
  • Imprimir a letra da canção de Natal “The Twelve Days of Christmas”, aproveitando a repetição da música.

Quando você estiver pronto para seguir em frente, vamos falar sobre um conceito do Rust que normalmente não existe em outras linguagens de programação: ownership.