Ferrugem - Loop

Pode haver casos em que um bloco de código precise ser executado repetidamente. Em geral, as instruções de programação são executadas sequencialmente: a primeira instrução em uma função é executada primeiro, seguida pela segunda e assim por diante.

As linguagens de programação fornecem várias estruturas de controle que permitem caminhos de execução mais complicados.

Uma instrução de loop nos permite executar uma instrução ou grupo de instruções várias vezes. A seguir, está a forma geral de uma instrução de loop na maioria das linguagens de programação.

Rust fornece diferentes tipos de loops para lidar com os requisitos de looping -

while
loop
for

Loop Definido

Um loop cujo número de iterações é definido / fixo é denominado como um loop definido. ofor loop é uma implementação de um loop definido.

For Loop

O loop for executa o bloco de código por um número especificado de vezes. Ele pode ser usado para iterar sobre um conjunto fixo de valores, como uma matriz. A sintaxe do loop for é a seguinte

Sintaxe

for temp_variable in lower_bound..upper_bound {
   //statements
}

Um exemplo de um loop for é mostrado abaixo

fn main(){
   for x in 1..11{ // 11 is not inclusive
      if x==5 {
         continue;
      }
      println!("x is {}",x);
   }
}

NOTE: que a variável x só está acessível dentro do bloco for.

Resultado

x is 1
x is 2
x is 3
x is 4
x is 6
x is 7
x is 8
x is 9
x is 10

Loop indefinido

Um loop indefinido é usado quando o número de iterações em um loop é indeterminado ou desconhecido.

Loops indefinidos podem ser implementados usando -

Sr. Não	Nome e Descrição
1	While A enquanto ciclo executa as instruções cada vez que a condição especificada for avaliada como True
2	Loop O loop é um loop while (true) indefinido

Ilustração - por enquanto

fn main(){
   let mut x = 0;
   while x < 10{
      x+=1;
      println!("inside loop x value is {}",x);
   }
   println!("outside loop x value is {}",x);
}

O resultado é mostrado abaixo -

inside loop x value is 1
inside loop x value is 2
inside loop x value is 3
inside loop x value is 4
inside loop x value is 5
inside loop x value is 6
inside loop x value is 7
inside loop x value is 8
inside loop x value is 9
inside loop x value is 10
outside loop x value is 10

Ilustração −loop

fn main(){
   //while true

   let mut x = 0;
   loop {
      x+=1;
      println!("x={}",x);

      if x==15 {
         break;
      }
   }
}

o breakdeclaração é usada para tirar o controle de uma construção. O uso de break em um loop faz com que o programa saia do loop.

Resultado

x=1
x=2
x=3
x=4
x=5
x=6
x=7
x=8
x=9
x=10
x=11
x=12
x=13
x=14
x=15

Continuar declaração

A instrução continue ignora as instruções subsequentes na iteração atual e leva o controle de volta ao início do loop. Ao contrário da instrução break, o continue não sai do loop. Ele termina a iteração atual e inicia a iteração subsequente.

Um exemplo da instrução continue é fornecido abaixo.

fn main() {

   let mut count = 0;

   for num in 0..21 {
      if num % 2==0 {
         continue;
      }
      count+=1;
   }
   println! (" The count of odd values between 0 and 20 is: {} ",count);
   //outputs 10
}

O exemplo acima exibe o número de valores pares entre 0 e 20. O loop sai da iteração atual se o número for par. Isso é obtido usando a instrução continue.

A contagem de valores ímpares entre 0 e 20 é 10