F# Loops

Aqui neste artigo, discutiremos loops F# , sua sintaxe , casos de uso comuns e veremos como usar loops em F#.

Durante esta sessão, também discutiremos as melhores práticas de loop e os erros mais comuns que devemos evitar ao usar loops.

Depois de ler este artigo, você deve ter uma compreensão clara de como os loops F# podem ser usados ​​para melhorar a eficiência e a capacidade de manutenção do seu código.

Para lidar com os requisitos de loop do aplicativo, F# fornece os seguintes tipos de loops.

  1. para... para e para... expressões para baixo
  2. para … em expressão
  3. Enquanto…faça um loop
  4. laços aninhados


F# Loops for…to e for…downto

Em um loop for…to , uma sequência de valores é iterada em ordem crescente, começando em um determinado valor e terminando em um determinado valor, até que o valor seja alcançado.

Por outro lado, loops for…downto são usados ​​para iterar sobre uma sequência de valores em ordem decrescente, começando com um valor e terminando com outro, começando de um valor especificado e iterando através dele.

Loops for...to são usados ​​na linguagem de programação F# na seguinte sintaxe

Sintaxe

for var = start-expr to end-expr do
    ... // loop body

Os loops For…downto são escritos na linguagem de programação F# com a seguinte sintaxe

for var = start-expr downto end-expr do
     ... // loop body

No programa a seguir, você verá os números de 1 a 10 impressos:

F# Loops Example: 1 

1
2
3
4
5
6
let main() =
for i = 1 to 10 do
printfn "Number: %i" i
main()
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

A saída a seguir será impressa após a conclusão da execução:

Number: 1
Number: 2
Number: 3
Number: 4
Number: 5
Number: 6
Number: 7
Number: 8
Number: 9
Number: 10

Aqui está um exemplo de programa que conta ao contrário e imprime os números 10 – 1 como resultado

F# Loops Example: 2 

1
2
3
4
5
6
let main() =
for i = 10 downto 1 do
printfn "Number: %i" i
main()
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Number: 10
Number: 9
Number: 8
Number: 7
Number: 6
Number: 5
Number: 4
Number: 3
Number: 2
Number: 1

Exemplo de Explicação

Este código é um exemplo de loop básico na linguagem de programação F#.

O código define uma função chamada main, que é o ponto de entrada do programa.

Dentro de main, há um loop for que faz a contagem regressiva de 10 a 1 usando a palavra-chave downto.

Durante cada iteração do loop, a variável do loop i é impressa no console usando a função printfn, que é uma função de impressão formatada que aceita uma string e um ou mais valores a serem interpolados na string.

A string sendo impressa neste caso é “ Number: %i “, que contém um espaço reservado para um valor inteiro. A variável i é fornecida como um argumento para a função printfn e substitui o espaço reservado na string.

Portanto, quando o programa for executado, ele produzirá números de 10 a 1, cada um precedido pela string “Número: “.


F# Loop – for…in

For…in loops em F# iteram sobre uma sequência de valores um por um. À medida que cada elemento da sequência é executado, a variável do loop recebe o valor de cada um dos elementos e, em seguida, o loop é repetido para cada elemento da sequência.

Um loop desse tipo geralmente é usado quando uma série de itens precisa ser processada, como uma lista de arquivos, ou quando uma soma ou média deve ser calculada.

Durante o processo de processamento de dados em F#, o loop for…in costuma ser usado como um mecanismo para transformar e filtrar dados à medida que são processados, em conjunto com outras construções de programação funcional, como pipelines.

Sintaxe

for pattern in enumerable-expression do
     body-expression

Abaixo está um exemplo simples de um loop for..in para iterar sobre uma lista de itens:

Example: 

1
2
3
4
5
let list1 = [ 1; 78; 120; 12; 29; 45 ]
for i in list1 do
printfn "%d" i
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
A seguir está uma saída do exemplo acima:
1
78
120
12
29
45

No exemplo abaixo, vamos pegar a soma da lista de exemplo acima:

Example: 

1
2
3
4
5
6
7
let list1 = [ 1; 78; 120; 12; 29; 45 ]
let mutable sum:int32 = 0
for i in list1 do
sum <- sum + i
printfn "%d" sum
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

O exemplo acima terá a seguinte saída:

1
79
199
211
240
285

Exemplo de Explicação

Esse código F# define uma lista de inteiros chamada list1 contendo seis valores e uma variável inteira mutável chamada sum que é inicialmente definida como 0.

O código então usa um loop for…in para iterar sobre os elementos list1. Durante cada iteração do loop, a variável do loop i assume o valor do elemento atual na lista.

Dentro do loop, o código atualiza o valor de sum adicionando o elemento atual i a ele usando o operador de atribuição <-mutável. O valor de soma atualizado é então impresso no console usando a função printfn.

Na verdade, esse loop itera sobre cada elemento da lista e calcula a soma corrente dos elementos, imprimindo cada soma intermediária no console.

Após a conclusão do loop, o valor final de sum conterá a soma total de todos os elementos da lista. E o valor final de sum seria 285, que é a soma de todos os elementos da lista.


F# – while..do Loops

F# permite que você execute repetidamente um bloco de código enquanto uma condição for verdadeira usando o loop while..do, que é uma construção de fluxo de controle que pode ser aplicada a qualquer bloco de código. Esse loop continua enquanto a condição não for falsa.

Existem algumas situações em que é útil usar esse loop se você tiver que repetir uma determinada ação repetidamente, por exemplo, ler um arquivo, processar dados ou até mesmo aguardar uma entrada do usuário. Esta é uma construção simples, flexível e poderosa que pode ser aplicada a uma ampla gama de cenários, dependendo da situação.

Sintaxe

while test-expression do
     body-expression

A seguir está um exemplo de iteração de valores de 1 a 10 usando um loop while:

Example: 

1
2
3
4
5
6
let mutable a = 1
while (a <= 10) do
printfn "Number a: %d" a
a <- a + 1
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

A saída do exemplo a seguir é a seguinte:

Number a: 1
Number a: 2
Number a: 3
Number a: 4
Number a: 5
Number a: 6
Number a: 7
Number a: 8
Number a: 9
Number a: 10

Exemplo de Explicação

Este é um código F# que usa um loop while para imprimir números de 1 a 10.

  1. A variável a é definida como um inteiro mutável com um valor inicial de 1.
  2. O loop while verifica se a é menor ou igual a 10. Se a for menor ou igual a 10, o loop continua.
  3. Dentro do loop while, usamos printfn “ Number a: %d ” a para imprimir o valor de a no console. %d é um espaço reservado que é substituído pelo valor de a.
  4. Depois de imprimir o valor de a, incrementamos o valor de a em 1 usando a instrução a <- a + 1 .
  5. O loop itera até que a não seja menor ou igual a 10.
  6. Após a conclusão do loop, o programa é encerrado.

Loops aninhados em F#

Na programação, iterar sobre coleções de dados está entre os conceitos mais comuns que você encontrará, e o F# permite que você faça isso de várias maneiras.

O loop aninhado é um deles. Um loop aninhado refere-se a um loop dentro de um loop. Esse método permite que os programadores iterem várias coleções de dados ao mesmo tempo de maneira semelhante. Em que os elementos individuais de cada coleção são iterados pelo loop interno, enquanto o loop externo controla o fluxo das iterações.

Um loop for aninhado pode ser expresso da seguinte maneira com base na seguinte sintaxe:

Sintaxe

for var1 = start-expr1 to end-expr1 do
     for var2 = start-expr2 to end-expr2 do
          ... // loop body

Um loop while aninhado pode ser expresso da seguinte maneira com base na seguinte sintaxe:

while test-expression1 do
     while test-expression2 do
         body-expression

O exemplo a seguir ilustra o uso de loops for aninhados:

Example: 

1
2
3
4
5
6
7
8
9
let main() =
for i = 1 to 5 do
printfn " "
for j=1 to 2*i-1 do
printf "*"
main()
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
O exemplo a seguir imprime a saída da seguinte maneira:
*
***
*****
*******
*********

Exemplo de Explicação

Este é um código F# que imprime uma pirâmide de asteriscos com 5 linhas.

  1. A função principal é definida sem argumentos de entrada.
  2. Dentro da função principal, usamos um loop for para iterar de 1 a 5. A variável do loop i representa a linha atual da pirâmide que estamos imprimindo.
  3. Antes de imprimir os asteriscos para cada linha, usamos printfn ” ” para imprimir um caractere de nova linha, que move o cursor para a próxima linha.
  4. Usamos outro loop for para imprimir os asteriscos para cada linha. A variável de loop j representa a coluna atual da pirâmide que estamos imprimindo.
  5. O número de asteriscos a serem impressos para cada linha é calculado usando a fórmula 2*i-1 . Esta fórmula nos dá um número ímpar de asteriscos para cada linha, o que é necessário para criar uma pirâmide simétrica.
  6. Dentro do loop interno, usamos printf “ * ” para imprimir um caractere asterisco.
  7. Depois de imprimir todos os asteriscos em uma linha, a instrução printfn move o cursor para a próxima linha. Isso está pronto para a próxima linha a ser impressa.
  8. Por fim, chamamos a função main para executar o código e imprimir a pirâmide .

O exemplo a seguir ilustra o uso de loops while aninhados:

Example: 

1
2
3
4
5
6
7
8
9
let mutable a=1;
while(a<=3) do
let mutable b = 1;
while (b < 3) do
printfn "%d %d" a b
b<- b+1
a<- a+1
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
A saída do exemplo acima é a seguinte:
1 1
1 2
2 1
2 2
3 1
3 2

Assine nosso boletim informativo abaixo para se manter atualizado com todos os desenvolvimentos mais recentes da linguagem de programação funcional F# e aprender mais sobre a linguagem.

Nós valorizamos o seu feedback.
+1
0
+1
0
+1
0
+1
0
+1
0
+1
0
+1
0

Assine a nossa newsletter
Digite seu e-mail para receber um resumo semanal de nossos melhores posts. Saber mais!
ícone