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.
fn main() {
let condition = true;
let number = if condition { 5 } else { 6 };
println!("The value of number is: {number}");
}
if a uma variávelA 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.
fn main() {
let mut number = 3;
while number != 0 {
println!("{number}!");
number -= 1;
}
println!("LIFTOFF!!!");
}
while para executar código enquanto uma condição é avaliada como trueEssa 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.
fn main() {
let a = [10, 20, 30, 40, 50];
let mut index = 0;
while index < 5 {
println!("the value is: {}", a[index]);
index += 1;
}
}
whileAqui, 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.
fn main() {
let a = [10, 20, 30, 40, 50];
for element in a {
println!("the value is: {element}");
}
}
forQuando 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.