Muitas vezes é útil executar um bloco de código mais de uma vez. Para essa tarefa, o [[Linguagem Rust|Rust]] fornece vários laços (loops), que percorrerão o código dentro do corpo do laço até o fim e, em seguida, retornarão imediatamente ao início. Para experimentar com laços, vamos criar um novo projeto chamado _loops_. O [[Linguagem Rust|Rust]] possui três tipos de laços: `loop`, `while` e `for`. Vamos testar cada um deles. # Repetindo Código com loop A palavra-chave `loop` instrui o [[Linguagem Rust|Rust]] a executar um bloco de código repetidamente para sempre ou até que você diga explicitamente para parar. Como exemplo, altere o arquivo `src/main.rs` no seu diretório _loops_ para que ele fique assim: Nome do arquivo: src/main.rs ```rust fn main() { loop { println!("again!"); } } ``` Felizmente, o Rust também oferece uma maneira de interromper um laço através do código. Você pode colocar a palavra-chave `break` dentro do laço para dizer ao programa quando parar de executá-lo. Também utilizamos o `continue`, que em um laço instrui o programa a pular qualquer código restante nesta iteração específica e seguir para a próxima iteração. # Retornando Valores de Laços Um dos usos de um `loop` é tentar novamente uma operação que você sabe que pode falhar, como verificar se uma thread concluiu seu trabalho. Você também pode precisar passar o resultado dessa operação do laço para o restante do seu código. Para fazer isso, você pode adicionar o valor que deseja retornar após a expressão `break` que utiliza para parar o laço; esse valor será retornado para fora do laço para que você possa utilizá-lo, como mostrado aqui: ```rust fn main() { let mut counter = 0; let result = loop { counter += 1; if counter == 10 { break counter * 2; } }; println!("The result is {result}"); } ``` Você também pode retornar de dentro de um laço. Enquanto o `break` apenas sai do laço atual, o `return` sempre sai da função atual. # Rótulos de Laço para Desambiguação entre Múltiplos Laços Se você tiver laços dentro de laços, o `break` e o `continue` aplicam-se ao laço mais interno naquele ponto. Opcionalmente, você pode especificar um _rótulo de laço_ (loop label) em um laço, que pode ser usado com `break` ou `continue` para especificar que essas palavras-chave se aplicam ao laço rotulado em vez de ao laço mais interno. Os rótulos de laço devem começar com uma aspa simples. Aqui está um exemplo com dois laços aninhados: ```rust 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}"); } ``` # Laços Condicionais com while Muitas vezes, um programa precisará avaliar uma condição dentro de um laço. Enquanto a condição for verdadeira, o laço é executado. Quando a condição deixa de ser verdadeira, o programa chama o `break`, parando o laço. É possível implementar um comportamento como este usando uma combinação de `loop`, `if`, `else` e `break`; você poderia tentar isso agora em um programa, se desejar. No entanto, esse padrão é tão comum que o [[Linguagem Rust|Rust]] possui uma estrutura de linguagem nativa para isso, chamada laço `while`. Na Listagem 3-3, usamos o `while` para repetir o programa três vezes, fazendo uma contagem regressiva a cada vez e, após o laço, imprimir uma mensagem e sair. Nome do arquivo: src/main.rs ```rust fn main() { let mut number = 3; while number != 0 { println!("{number}!"); number -= 1; } println!("LIFTOFF!!!"); } ``` # Percorrendo uma Coleção com for Você também pode usar a estrutura `while` para percorrer os elementos de uma coleção, como um array. Por exemplo, o laço na Listagem 3-4 imprime cada elemento no array `a`. Nome do arquivo: src/main.rs ```rust fn main() { let a = [10, 20, 30, 40, 50]; let mut index = 0; while index < 5 { println!("the value is: {}", a[index]); index += 1; } } ``` ## Percorrendo uma Coleção com `for` Como uma alternativa mais concisa, você pode usar um laço `for` e executar algum código para cada item em uma coleção. Um laço `for` se parece com o código na Listagem 3-5. ```rust fn main() { let a = [10, 20, 30, 40, 50]; for element in a { println!("the value is: {element}"); } } ``` ```bash $ cargo run -q the value is: 10 the value is: 20 the value is: 30 the value is: 40 the value is: 50 ``` **:: Referência ::** [Control Flow - The Rust Programming Language](https://doc.rust-lang.org/book/ch03-05-control-flow.html)