Usar loops para iterar nas instruções

  • 4 minutos

Você chegou a um ponto no programa em que precisa executar um grupo de instruções mais de uma vez. Você poderá trabalhar com uma estrutura de tipo de lista que precisa para iteração. Ou, então, você tem uma necessidade geral de repetir uma operação até que determinada condição seja atendida. Nesses cenários, você pode usar os loops.

Loops

Um loop é iterado em um intervalo de valores. Para cada valor, o código faz algo, como imprimir resultados em uma tela ou usar o valor em uma operação. O F# tem três tipos de loops que você pode usar:

  • for...in: o constructo for...in considera que você tem uma coleção enumerável na qual pode iterar. Ele itera em cada valor em uma coleção.
  • for...to: o loop for...to é iniciado e encerrado onde esse loop é iterado. Ele itera até atingir o valor de uma variável de loop.
  • while...do: o loop while...do não é centralizado em uma coleção enumerável como os dois primeiros constructos. Em vez disso, ele faz loop até que uma condição seja atendida.

Usar um loop for...in para cada valor em uma coleção

O constructo for...in opera em uma coleção enumerável. Ele implementa System.Collections.IEnumerable e inclui listas, sequências, matrizes e outros tipos. Esta é a sintaxe de um loop for...in:

for <pattern> in <enumerable-expression> do
  <body-expression>

É importante entender algumas palavras-chave:

  • Padrão: o padrão pode ser o item atual ou uma tupla. Um exemplo é a iteração em uma sequência. O código a seguir é um exemplo de quando o padrão é o valor atual i. O for itera na lista list e depois imprime cada valor na coleção:

    let list = [1; 2; 3; 4; 5]
for i in list do
   printf "%d " i

  • Expressão enumerável: A expressão enumerável é o que você está iterando. Pode ser uma lista ou uma sequência.

  • Expressão corporal: a expressão do corpo é onde você realiza a tarefa que deseja fazer, como imprimir ou executar um cálculo.

Usar um loop for...to até que ocorra uma variável de looping

O constructo for...to é um pouco diferente de um loop for...in. A variável de loop for...to constitui um limite no qual a iteração é interrompida. A sintaxe teria a seguinte aparência:

for <identifier = start> [ to | downto ] <finish> do
    <body-expression>

É importante entender os componentes da sintaxe:

  • identifier = start: essa sintaxe é uma atribuição. Geralmente, você decide qual variável quer acompanhar na iteração e em qual valor ela deve começar.
  • [to | downto]: você pode escolher entre duas palavras-chave diferentes. to significa que o loop itera até esse número. Se você usar downto, o valor do identificador diminuirá até atingir esse número.

Veja um exemplo de como usar um loop for...to:

for i = 1 to 10 do
  printfn "%i " i  // prints 1 2 3 4 5 6 7 8 9 10

Esse loop imprime todos os valores entre 1 e 10, incluindo 10. Vejamos também um exemplo que usa o constructo for...downto. Esse constructo funciona de modo semelhante ao for...to, mas na ordem inversa. O seguinte código mostra como imprimir os valores de 10 até 1, incluindo o 1:

for i = 10 downto 1 do
  printfn "%i" i  // prints 10 9 8 7 6 5 4 3 2 1

Usar um loop while...do até que uma condição seja atendida

O constructo while...do é diferente dos constructos for...in e for...to. O while...do não itera em uma coleção. Use um loop while...do se você tiver uma lógica que precise executar um loop até que uma condição seja atendida. Um exemplo é aceitar argumentos da linha de comando até que um usuário insira encerrar.

Este código mostra a sintaxe de um constructo while...do:

while <test-expression> do
  <body-expression>

Um jogo de adivinhação é um exemplo de uso de um constructo while...do:

open System

let mutable quit = false
let no = 11
while not quit do
   printf "Guess a number: "
   let guess = Console.ReadLine() 
   let guessNo = int guess
   if guessNo = no then
      quit <- true
      printfn "You guessed correctly %i is the secret number" no
   else
      printfn "%i is incorrect" guessNo

O código executa um conjunto de instruções até que a variável quit tenha o valor true. Ao definir o valor de quit como true, quando um usuário faz a adivinhação correta, o loop é encerrado.