For loop - For loop

Para diagrama de fluxo de loop

Na ciência da computação , um loop for (ou simplesmente loop for) é uma instrução de fluxo de controle para especificar a iteração , que permite que o código seja executado repetidamente. Várias palavras-chave são usadas para especificar esta declaração: descendentes de ALGOL usam "for", enquanto descendentes de Fortran usam "do". Existem outras possibilidades, por exemplo COBOL que usa "PERFORM VARYING".

Um loop for tem duas partes: um cabeçalho especificando a iteração e um corpo que é executado uma vez por iteração. O cabeçalho freqüentemente declara um contador de loop explícito ou variável de loop, que permite ao corpo saber qual iteração está sendo executada. Os loops For são normalmente usados quando o número de iterações é conhecido antes de entrar no loop. Os loops for podem ser considerados atalhos para loops while que incrementam e testam uma variável de loop.

O nome for-loop vem da palavra for , que é usada como palavra - chave em muitas linguagens de programação para introduzir um for-loop. O termo em inglês data do ALGOL 58 e foi popularizado no influente ALGOL 60 posterior ; é a tradução direta do alemão anterior für , usado no Superplan (1949–1951) por Heinz Rutishauser , que também esteve envolvido na definição do ALGOL 58 e ALGOL 60. O corpo do loop é executado "para" os valores dados da variável do loop , embora isso seja mais explícito na versão ALGOL da instrução, na qual uma lista de valores e / ou incrementos possíveis pode ser especificada.

Em FORTRAN e PL / I , a palavra-chave DO é usada para a mesma coisa e é chamada de do-loop ; isso é diferente de um loop do-while .

PARA

Para ilustração de loop, de i = 0 a i = 2, resultando em data1 = 200

Uma instrução for-loop está disponível na maioria das linguagens de programação imperativas . Mesmo ignorando pequenas diferenças de sintaxe, há muitas diferenças em como essas instruções funcionam e no nível de expressividade que suportam. Geralmente, os loops for se enquadram em uma das seguintes categorias:

For-loops tradicionais

O loop for de linguagens como ALGOL , Simula , BASIC , Pascal , Modula , Oberon , Ada , Matlab , Ocaml , F # e assim por diante, requer uma variável de controle com valores iniciais e finais e se parece com isto:

for i = first to last do statement
(* or just *)
for i = first..last do statement

Dependendo do idioma, um sinal de atribuição explícito pode ser usado no lugar do sinal de igual (e alguns idiomas exigem a palavra, intmesmo no caso numérico). Um valor de etapa opcional (um incremento ou decremento ≠ 1) também pode ser incluído, embora as sintaxes exatas usadas para isso difiram um pouco mais entre os idiomas. Algumas linguagens requerem uma declaração separada da variável de controle, outras não.

Outra forma foi popularizado pela linguagem de programação C . Requer 3 partes: a inicialização ( variante de loop ), a condição e o avanço para a próxima iteração. Todas essas três partes são opcionais. Este tipo de "loops de ponto e vírgula" veio da linguagem de programação B e foi originalmente inventado por Stephen Johnson .

Na parte de inicialização, todas as variáveis necessárias são declaradas (e geralmente valores atribuídos). Se várias variáveis forem declaradas, todas devem ser do mesmo tipo. A parte da condição verifica uma determinada condição e sai do loop se for falsa. O avanço para a próxima parte da iteração é executado exatamente uma vez sempre que o loop termina. O loop é então repetido se a condição for avaliada como verdadeira.

Aqui está um exemplo do tradicional for-loop estilo C em Java .

// Prints the numbers from 0 to 99 (and not 100), each followed by a space. 

for (int i=0; i<100; i++)  
{
    System.out.print(i);
    System.out.print(' ');
}
System.out.println();

Esses loops também são chamados de loops for numéricos quando contrastados com loops foreach (veja abaixo).

For-loops baseados em iterador

Este tipo de loop for é uma generalização do tipo de intervalo numérico do loop for, pois permite a enumeração de conjuntos de itens diferentes de sequências numéricas. Geralmente é caracterizado pelo uso de um iterador implícito ou explícito , no qual a variável de loop assume cada um dos valores em uma sequência ou outra coleta de dados. Um exemplo representativo em Python é:

for item in some_iterable_object:
    do_something()
    do_something_else()

Onde some_iterable_objectestá uma coleção de dados que suporta iteração implícita (como uma lista de nomes de funcionários) ou pode, na verdade, ser um iterador em si. Algumas linguagens têm isso além de outra sintaxe for-loop; notavelmente, o PHP tem este tipo de loop sob o nome for each, bem como um loop for de três expressões (veja abaixo) sob o nome for.

For-loops vetorizados

Algumas linguagens oferecem um loop for que atua como se processasse todas as iterações em paralelo , como a for allpalavra - chave em FORTRAN 95, que tem a interpretação de que todas as expressões do lado direito são avaliadas antes de quaisquer atribuições serem feitas, como distinto da iteração explícita Formato. Por exemplo, na forinstrução do fragmento de pseudocódigo a seguir, ao calcular o novo valor para A(i), exceto para o primeiro (com i = 2) a referência a A(i - 1)obterá o novo valor que foi colocado ali na etapa anterior. Na for allversão, porém, cada cálculo refere-se apenas ao original, inalterado A.

for     i := 2 : N - 1 do A(i) := [A(i - 1) + A(i) + A(i + 1)] / 3; next i;
for all i := 2 : N - 1 do A(i) := [A(i - 1) + A(i) + A(i + 1)] / 3;

A diferença pode ser significativa.

Algumas linguagens (como FORTRAN 95, PL / I) também oferecem instruções de atribuição de matriz, que permitem que muitos loops for sejam omitidos. Portanto, pseudocódigo como definiria A := 0;todos os elementos da matriz A para zero, não importando seu tamanho ou dimensionalidade. O loop de exemplo pode ser renderizado como

 A(2 : N - 1) := [A(1 : N - 2) + A(2 : N - 1) + A(3 : N)] / 3;

Mas se isso seria renderizado no estilo for-loop ou for all-loop ou qualquer outra coisa, pode não estar claramente descrito no manual do compilador.

For-loops compostos

Introduzido com ALGOL 68 e seguido por PL / I , isso permite que a iteração de um loop seja combinada com um teste, como em

for i := 1 : N while A(i) > 0 do etc.

Ou seja, um valor é atribuído à variável de loop i e somente se a expressão while for verdadeira o corpo do loop será executado. Se o resultado for falso, a execução do loop for é interrompida. Supondo que o valor da variável de loop seja definido após o término do loop, a instrução acima encontrará o primeiro elemento não positivo na matriz A (e se não for, seu valor será N + 1 ), ou, com variações adequadas , o primeiro caractere não vazio em uma string e assim por diante.

Contadores de loop

Na programação de computadores, um contador de loop é a variável que controla as iterações de um loop (uma construção de linguagem de programação de computador ). É assim chamado porque a maioria dos usos desta construção resulta na variável assumindo uma gama de valores inteiros em algumas sequências ordenadas (exemplo, começando em 0 e terminando em 10 em incrementos de 1)

Os contadores de loop mudam com cada iteração de um loop, fornecendo um valor exclusivo para cada iteração individual. O contador de loop é usado para decidir quando o loop deve terminar e para o fluxo do programa continuar para a próxima instrução após o loop.

Uma convenção de nomenclatura de identificador comum é que o contador de loop use os nomes de variáveis i , j e k (e assim por diante, se necessário), onde i seria o loop mais externo, j o próximo loop interno, etc. A ordem inversa é também usado por alguns programadores. Esse estilo é geralmente aceito como originado da programação inicial do FORTRAN , onde esses nomes de variáveis que começam com essas letras foram declarados implicitamente como tendo um tipo inteiro e, portanto, eram escolhas óbvias para contadores de loop que eram necessários apenas temporariamente. A prática remonta à notação matemática onde os índices para somas e multiplicações são frequentemente i , j , etc. Uma convenção variante é o uso de letras reduplicadas para o índice, ii , jj e kk , pois isso permite uma pesquisa e pesquisa mais fáceis. substituindo do que usando uma única letra.

Exemplo

Um exemplo de código C envolvendo loops for aninhados, onde as variáveis do contador de loop são i e j :

for (i = 0; i < 100; i++) {
    for (j = i; j < 10; j++) {
        some_function(i, j);
    }
}

Foi demonstrado que um loop for aninhado, como no exemplo acima, realiza mais cálculos por unidade de tempo do que um loop sem ele. Essa otimização independente da máquina significa que o loop for aninhado terminará mais rápido, dado o mesmo número de cálculos a serem executados. Esta é uma vantagem que o loop for aninhado tem sobre o loop while aninhado, que se comporta de maneira diferente.

Os loops For em C também podem ser usados para imprimir o reverso de uma palavra. Como:

for (i = 0; i < 6; i++) {
    scanf("%c", &a[i]);
}
for (i = 4; i >= 0; i--) {
    printf("%c", a[i]);
}

Aqui, se a entrada for apple, a saída será elppa.

Semântica e construções adicionais

Use como loops infinitos

Este for-loop estilo C é comumente a fonte de um loop infinito, uma vez que as etapas fundamentais da iteração estão completamente sob o controle do programador. Na verdade, quando se pretendem loops infinitos, este tipo de loop for pode ser usado (com expressões vazias), como:

for (;;)
    //loop body

Este estilo é usado em vez de while (1)loops infinitos para evitar um aviso de conversão de tipo em alguns compiladores C / C ++. Alguns programadores preferem a forma mais sucinta em vez da for (;;)forma semanticamente equivalente, mas mais detalhada while (true).

Saída antecipada e continuação

Algumas linguagens também podem fornecer outras instruções de suporte, que, quando presentes, podem alterar como a iteração for-loop prossegue. Comum entre eles estão as instruções break e continue encontradas em C e seus derivados. A instrução break faz com que o loop mais interno seja encerrado imediatamente quando executado. A instrução continue irá mover-se imediatamente para a próxima iteração sem mais progresso através do corpo do loop para a iteração atual. Uma instrução for também termina quando uma instrução break, goto ou return dentro do corpo da instrução é executada. [Wells] Outras linguagens podem ter declarações semelhantes ou de outra forma fornecer meios para alterar o progresso do loop for; por exemplo em FORTRAN 95:

DO I = 1, N
  statements               !Executed for all values of "I", up to a disaster if any.
  IF (no good) CYCLE       !Skip this value of "I", continue with the next.
  statements               !Executed only where goodness prevails.
  IF (disaster) EXIT       !Abandon the loop.
  statements               !While good and, no disaster.
END DO                     !Should align with the "DO".

Algumas linguagens oferecem recursos adicionais, como nomear as várias instruções de loop para que, com vários loops aninhados, não haja dúvidas sobre qual loop está envolvido. Fortran 95, por exemplo:

X1:DO I = 1,N
     statements
  X2:DO J = 1,M
       statements
       IF (trouble) CYCLE X1
       statements
     END DO X2
     statements
   END DO X1

Assim, quando um "problema" é detectado no loop interno, o CYCLE X1 (não X2) significa que o salto será para a próxima iteração de I, não J. O compilador também verificará se cada END DO tem o rótulo apropriado para a sua posição: este não é apenas um auxílio de documentação. O programador ainda deve codificar o problema corretamente, mas alguns erros possíveis serão bloqueados.

Escopo e semântica da variável de loop

Linguagens diferentes especificam regras diferentes para qual valor a variável de loop manterá no término de seu loop e, de fato, alguns sustentam que ela "se torna indefinida". Isso permite que um compilador gere código que deixa qualquer valor na variável de loop, ou talvez até mesmo o deixe inalterado porque o valor do loop foi mantido em um registro e nunca armazenado na memória. O comportamento real pode até variar de acordo com as configurações de otimização do compilador, como no compilador Honywell Fortran66.

Em algumas linguagens (não C ou C ++ ), a variável de loop é imutável dentro do escopo do corpo do loop, com qualquer tentativa de modificar seu valor sendo considerada um erro semântico. Essas modificações às vezes são consequência de um erro do programador, que pode ser muito difícil de identificar depois de feito. No entanto, apenas mudanças abertas são provavelmente detectadas pelo compilador. Situações onde o endereço da variável de loop é passado como um argumento para uma sub - rotina tornam muito difícil a verificação, porque o comportamento da rotina é geralmente desconhecido para o compilador. Alguns exemplos no estilo do Fortran:

DO I = 1, N
  I = 7                           !Overt adjustment of the loop variable. Compiler complaint likely.
  Z = ADJUST(I)                   !Function "ADJUST" might alter "I", to uncertain effect.
  normal statements               !Memory might fade that "I" is the loop variable.
  PRINT (A(I), B(I), I = 1, N, 2) !Implicit for-loop to print odd elements of arrays A and B, reusing "I"...
  PRINT I                         !What value will be presented?
END DO                            !How many times will the loop be executed?

Uma abordagem comum é calcular a contagem de iteração no início de um loop (com atenção cuidadosa ao estouro como na for i := 0 : 65535 do ... ;aritmética de inteiros de dezesseis bits) e com cada decremento de iteração essa contagem enquanto também ajusta o valor de I : resultados de contagem dupla. No entanto, os ajustes no valor de I dentro do loop não alterarão o número de iterações executadas.

Ainda outra possibilidade é que o código gerado pode empregar uma variável auxiliar como a variável de loop, possivelmente mantida em um registro de máquina, cujo valor pode ou não ser copiado para I em cada iteração. Novamente, as modificações de I não afetariam o controle do loop, mas agora uma disjunção é possível: dentro do loop, as referências ao valor de I podem ser para o valor atual (possivelmente alterado) de I ou para a variável auxiliar (mantida seguro contra modificações impróprias) e resultados confusos são garantidos. Por exemplo, dentro do loop, uma referência ao elemento I de uma matriz provavelmente empregaria a variável auxiliar (especialmente se fosse mantida em um registro de máquina), mas se I fosse um parâmetro para alguma rotina (por exemplo, uma instrução de impressão para revelar seu valor), provavelmente seria uma referência à variável I apropriada . É melhor evitar essas possibilidades.

Ajuste de limites

Assim como a variável de índice pode ser modificada dentro de um loop for, também podem ser seus limites e direção. Mas com efeito incerto. Um compilador pode impedir tais tentativas, elas podem não ter efeito, ou podem até funcionar corretamente - embora muitos declarem que fazer isso seria errado. Considere uma declaração como

for i := first : last : step do
  A(i) := A(i) / A(last);

Se a abordagem para compilar tal loop fosse a avaliação do primeiro , último e passo e o cálculo de uma contagem de iteração por meio de algo como (last - first)/stepuma única vez no início, então se esses itens fossem variáveis simples e seus valores fossem de alguma forma ajustados durante o iterações, isso não teria efeito na contagem de iterações, mesmo se o elemento selecionado para divisão por fosse A(last)alterado.

Lista de intervalos de valores

PL / I e Algol 68 permitem loops nos quais a variável de loop é iterada em uma lista de intervalos de valores em vez de um único intervalo. O seguinte exemplo PL / I executará o loop com seis valores de i: 1, 7, 12, 13, 14, 15:

do i = 1, 7, 12 to 15;
  /*statements*/
end;

Equivalência com while-loops

Um loop for é geralmente equivalente a um loop while:

factorial := 1
 for counter from 2 to 5
     factorial := factorial * counter
counter := counter - 1
print counter + "! equals " + factorial

é equivalente a:

factorial := 1
counter := 1
 while counter < 5
    counter := counter + 1
    factorial := factorial * counter
print counter + "! equals " + factorial

conforme demonstrado pela saída das variáveis.

Linha do tempo da sintaxe for-loop em várias linguagens de programação

Dada uma ação que deve ser repetida, por exemplo, cinco vezes, os for-loops de diferentes idiomas serão escritos de forma diferente. A sintaxe para um loop for de três expressões é quase idêntica em todas as linguagens que a possuem, após considerar diferentes estilos de terminação de bloco e assim por diante.

1957: FORTRAN

Equivalente do Fortran para circuito é o DO loop, utilizando palavras-chave fazer em vez de para, a sintaxe de Fortran DO circuito é:

        DO label counter = first, last, step
          statements
label     statement

Os dois exemplos a seguir se comportam de maneira equivalente aos três argumentos for-loop em outras linguagens, inicializando a variável counter para 1, incrementando em 1 cada iteração do loop e parando em cinco (inclusive).

        DO 9, COUNTER = 1, 5, 1
          WRITE (6,8) COUNTER
    8     FORMAT( I2 )
    9   CONTINUE

No Fortran 77 (ou posterior), isso também pode ser escrito como:

do counter = 1, 5
  write(*, '(i2)') counter
end do

A parte da etapa pode ser omitida se a etapa for uma. Exemplo:

* DO loop example.
       PROGRAM MAIN
         SUM SQ = 0
         DO 199 I = 1, 9999999
           IF (SUM SQ.GT.1000) GO TO 200
199        SUM SQ = SUM SQ + I**2
200      PRINT 206, SUMSQ
206      FORMAT( I2 )
       END

Os espaços são irrelevantes nas instruções Fortran de formato fixo, portanto, SUM SQ é igual a SUMSQ . No moderno estilo Fortran de forma livre, os espaços em branco são significativos.

No Fortran 90, o GO TO pode ser evitado usando uma instrução EXIT .

* DO loop example.
       program main
         implicit none

         integer :: sumsq
         integer :: i

         sumsq = 0
         do i = 1, 9999999
           if (sumsq > 1000.0) exit
           sumsq = sumsq + i**2
          end do
         print *, sumsq

       end program

1958: ALGOL

ALGOL 58 apresentou a fordeclaração, usando o formulário como Superplan:

 FOR Identifier = Base (Difference) Limit

Por exemplo, para imprimir de 0 a 10 incrementado por 1:

FOR x = 0 (1) 10 BEGIN
PRINT (FL) = x END

1960: COBOL

O COBOL foi formalizado no final de 1959 e teve muitas elaborações. Ele usa o verbo PERFORM, que tem muitas opções. Originalmente, todos os loops precisavam estar fora de linha, com o código iterado ocupando um parágrafo separado. Ignorando a necessidade de declarar e inicializar variáveis, o equivalente COBOL de um for -loop seria.

      PERFORM SQ-ROUTINE VARYING I FROM 1 BY 1 UNTIL I > 1000

      SQ-ROUTINE
             ADD I**2 TO SUM-SQ.

Na década de 1980, a adição de loops em linha e instruções "estruturadas", como END-PERFORM, resultou em um for -loop com uma estrutura mais familiar.

      PERFORM VARYING I FROM 1 BY 1 UNTIL I > 1000
             ADD I**2 TO SUM-SQ.
      END-PERFORM

Se o verbo PERFORM tiver a cláusula opcional TEST AFTER, o loop resultante será um pouco diferente: o corpo do loop é executado pelo menos uma vez, antes de qualquer teste.

1964: BASIC

Os loops em BASIC às vezes são chamados de loops próximos.

10 REM THIS FOR LOOP PRINTS ODD NUMBERS FROM 1 TO 15
20 FOR I = 1 TO 15 STEP 2
30 PRINT I
40 NEXT I

Observe que o marcador de loop final especifica o nome da variável de índice, que deve corresponder ao nome da variável de índice no início do loop for. Algumas linguagens (PL / I, FORTRAN 95 e posterior) permitem um rótulo de instrução no início de um loop for que pode ser correspondido pelo compilador com o mesmo texto na instrução end-loop correspondente. Fortran também permite que as instruções EXITe CYCLEnomeiem este texto; em um ninho de loops, isso deixa claro qual é o loop pretendido. No entanto, nessas linguagens, os rótulos devem ser únicos, de modo que loops sucessivos envolvendo a mesma variável de índice não podem usar o mesmo texto nem um rótulo pode ser o mesmo que o nome de uma variável, como a variável de índice do loop.

1964: PL / I

do counter = 1 to 5 by 1; /* "by 1" is the default if not specified */
  /*statements*/;
  end;

A instrução LEAVE pode ser usada para sair do loop. Os loops podem ser rotulados, e leave pode deixar um loop rotulado específico em um grupo de loops aninhados. Alguns dialetos PL / I incluem a instrução ITERATE para encerrar a iteração do loop atual e iniciar a próxima.

1968: Algol 68

ALGOL 68 tem o que foi considerado o loop universal, a sintaxe completa é:

FOR i FROM 1 BY 2 TO 3 WHILE i≠4 DO ~ OD

Além disso, o intervalo de iteração única pode ser substituído por uma lista de tais intervalos. Existem vários aspectos incomuns do construto

apenas a do ~ odparte era obrigatória, caso em que o loop iterará indefinidamente.
portanto, a cláusula to 100 do ~ odirá iterar exatamente 100 vezes.
o while elemento sintático permitia a um programador interromper um forloop antecipadamente, como em:

INT sum sq := 0;
FOR i
 WHILE
  print(("So far:", i, new line)); # Interposed for tracing purposes. #
  sum sq ≠ 70↑2                    # This is the test for the WHILE   #
DO
  sum sq +:= i↑2
OD

Subsequentes extensões para o padrão Algol68 permitido o toelemento sintáctica a ser substituído com uptoe downtopara alcançar uma pequena optimização. Os mesmos compiladores também incorporaram:

until: para finalização tardia do loop.
foreach: para trabalhar em matrizes em paralelo .

1970: Pascal

for Counter := 1 to 5 do
  (*statement*);

Decrementar (contagem regressiva) é usar downtopalavras-chave em vez de to, como em:

for Counter := 5 downto 1 do
  (*statement*);

O intervalo numérico para o loop varia um pouco mais.

1972: C / C ++

for (initialization; condition; increment/decrement)
    statement

A instrução geralmente é uma instrução em bloco; um exemplo disso seria:

//Using for-loops to add numbers 1 - 5
int sum = 0;
for (int i = 1; i < 6; ++i) {
    sum += i;
}

A publicação ISO / IEC 9899: 1999 (comumente conhecida como C99 ) também permite declarações iniciais em forloops. Todas as três seções no loop for são opcionais.

1972: Smalltalk

1 to: 5 do: [ :counter | "statements" ]

Ao contrário de outras linguagens, em Smalltalk um loop for não é uma construção de linguagem, mas definido na classe Number como um método com dois parâmetros, o valor final e um fechamento , usando self como valor inicial.

1980: Ada

for Counter in 1 .. 5 loop
   -- statements
end loop;

A instrução de saída pode ser usada para sair do loop. Os loops podem ser rotulados e a saída pode deixar um loop especificamente rotulado em um grupo de loops aninhados:

Counting:
    for Counter in 1 .. 5 loop
   Triangle:
       for Secondary_Index in 2 .. Counter loop
          -- statements
          exit Counting;
          -- statements
       end loop Triangle;
    end loop Counting;

1980: Maple

O Maple tem duas formas de loop for, uma para iterar um intervalo de valores e outra para iterar sobre o conteúdo de um contêiner. O formato do intervalo de valores é o seguinte:

for i from f by b to t while w do
    # loop body
od;

Todas as peças, exceto doe odsão opcionais. A parte, se presente, deve vir primeiro. As partes restantes ( , , , ) podem aparecer em qualquer ordem. for ifrom fby bto twhile w

A iteração em um contêiner é feita usando esta forma de loop:

for e in c while w do
    # loop body
od;

A cláusula especifica o contêiner, que pode ser uma lista, conjunto, soma, produto, função não avaliada, matriz ou um objeto que implementa um iterador. in c

Uma for-loop pode ser encerrado por od, end, ou end do.

1982: Maxima CAS

No Maxima CAS pode-se usar também valores não inteiros:

for x:0.5 step 0.1 thru 0.9 do
    /* "Do something with x" */

1982: PostScript

O loop for, escrito como [initial] [increment] [limit] { ... } forinicializa uma variável interna, executa o corpo desde que a variável interna não seja maior que o limite (ou não menor, se o incremento for negativo) e, ao final de cada iteração, incrementa a variável interna. Antes de cada iteração, o valor da variável interna é colocado na pilha.

1 1 6 {STATEMENTS} for

Também existe um loop de repetição simples. O loop de repetição, escrito como X { ... } repeat, repete o corpo exatamente X vezes.

5 { STATEMENTS } repeat

1983: Ada 83 e acima

procedure Main is
  Sum_Sq : Integer := 0;
begin
  for I in 1 .. 9999999 loop 
    if Sum_Sq <= 1000 then
      Sum_Sq := Sum_Sq + I**2
    end if;
  end loop;
end;

1984: MATLAB

for n = 1:5 
     -- statements
end

Após o loop, nseria 5 neste exemplo.

Como ié usado para a unidade Imaginária , seu uso como uma variável de loop é desencorajado.

1987: Perl

for ($counter = 1; $counter <= 5; $counter++) { # implicitly or predefined variable
    # statements;
}
for (my $counter = 1; $counter <= 5; $counter++) { # variable private to the loop
    # statements;
}
for (1..5) { # variable implicitly called $_; 1..5 creates a list of these 5 elements
    # statements;
}
statement for 1..5; # almost same (only 1 statement) with natural language order
for my $counter (1..5) { # variable private to the loop
    # statements;
}

(Observe que " há mais de uma maneira de fazer isso " é um lema de programação Perl.)

1988: Mathematica

A construção correspondente ao loop for da maioria das outras linguagens é chamada de Do no Mathematica

Do[f[x], {x, 0, 1, 0.1}]

O Mathematica também tem uma construção For que imita o loop for de linguagens semelhantes a C

For[x= 0 , x <= 1, x += 0.1,
    f[x]
]

1989: Bash

# first form
for i in 1 2 3 4 5
do
    # must have at least one command in loop
    echo $i  # just print value of i
done

# second form
for (( i = 1; i <= 5; i++ ))
do
    # must have at least one command in loop
    echo $i  # just print value of i
done

Observe que um loop vazio (ou seja, um sem comandos entre doe done) é um erro de sintaxe. Se os loops acima contivessem apenas comentários, a execução resultaria na mensagem "erro de sintaxe próximo ao token inesperado 'concluído'".

1990: Haskell

O imperativo embutido forM_ mapeia uma expressão monádica em uma lista, como

forM_ [1..5] $ \indx -> do statements

ou obtenha cada resultado de iteração como uma lista em

statements_result_list <- forM [1..5] $ \indx -> do statements

Mas, se você quiser economizar espaço da lista [1..5], uma construção monádica mais autêntica para Loop_ pode ser definida como

import Control.Monad as M

forLoopM_ :: Monad m => a -> (a -> Bool) -> (a -> a) -> (a -> m ()) -> m ()
forLoopM_ indx prop incr f = do
        f indx
        M.when (prop next) $ forLoopM_ next prop incr f
  where      
    next = incr indx

e usado como:

  forLoopM_ (0::Int) (< len) (+1) $ \indx -> do -- whatever with the index

1991: Oberon-2, Oberon-07 ou Component Pascal

FOR Counter := 1 TO 5 DO
  (* statement sequence *)
END

Observe que na linguagem Oberon original o loop for foi omitido em favor da construção de loop Oberon mais geral. O loop for foi reintroduzido em Oberon-2.

1991: Python

Python não contém o loop for clássico, em vez disso, um foreachloop é usado para iterar sobre a saída da range()função embutida que retorna uma lista iterável de inteiros.

for i in range(1, 6):  # gives i values from 1 to 5 inclusive (but not 6)
    # statements
    print(i)
# if we want 6 we must do the following
for i in range(1, 6 + 1):  # gives i values from 1 to 6
    # statements
    print(i)

O uso range(6)executaria o loop de 0 a 5.

1993: AppleScript

repeat with i from 1 to 5
	-- statements
	log i
end repeat

Você também pode iterar por meio de uma lista de itens, semelhante ao que pode fazer com matrizes em outras linguagens:

set x to {1, "waffles", "bacon", 5.1, false}
repeat with i in x
	log i
end repeat

Você também pode usar exit repeatpara sair de um loop a qualquer momento. Ao contrário de outras linguagens, o AppleScript não tem atualmente nenhum comando para continuar para a próxima iteração de um loop.

1993: Lua

for i = start, stop, interval do
  -- statements
end

Então, este código

for i = 1, 5, 2 do
  print(i)
end

irá imprimir:

1 3 5

For-loops também podem percorrer uma tabela usando

ipairs()

para iterar numericamente por meio de matrizes e

pairs()

para iterar aleatoriamente por meio de dicionários.

For-loop genérico que usa fechos :

for name, phone, address in contacts() do
  -- contacts() must be an iterator function
end

1995: CFML

Sintaxe do script

Loop de índice simples:

for (i = 1; i <= 5; i++) {
	// statements
}

Usando uma matriz:

for (i in [1,2,3,4,5]) {
	// statements
}

Usando uma lista de valores de string:

loop index="i" list="1;2,3;4,5" delimiters=",;" {
	// statements
}

O listexemplo acima está disponível apenas no dialeto de CFML usado por Lucee e Railo .

Sintaxe de tag