En bucle

En informática, un bucle for o un bucle for es una declaración de flujo de control para especificar la iteración. Específicamente, un bucle for funciona ejecutando una sección de código repetidamente hasta que se cumple una determinada condición.

Los bucles For tienen dos partes: un encabezado y un cuerpo. El encabezado define la iteración y el cuerpo es el código que se ejecuta una vez por iteración. El encabezado a menudo declara un contador de bucle explícito o una variable de bucle. Esto le permite al cuerpo saber qué iteración se está ejecutando. Los bucles For se utilizan normalmente cuando se conoce el número de iteraciones antes de ingresar al bucle. Los bucles For pueden considerarse como abreviaturas de bucles while que incrementan y prueban una variable de bucle.

Se utilizan varias palabras clave para indicar el uso de un bucle for: los descendientes de ALGOL usan "for", mientras que los descendientes de Fortran usan "hacer". Hay otras posibilidades, por ejemplo COBOL que usa REALIZAR VARIACIÓN.

El nombre for-loop proviene de la palabra for. For se utiliza como palabra clave en muchos lenguajes de programación para introducir un bucle for. El término en inglés data de ALGOL 58 y se popularizó en ALGOL 60. Es la traducción directa del anterior alemán für y fue utilizado en Superplan (1949-1951) por Heinz Rutishauser.. Rutishauser participó en la definición de ALGOL 58 y ALGOL 60. El cuerpo del bucle se ejecuta "for" los valores dados de la variable de bucle. Esto es más explícito en las versiones ALGOL de la declaración for donde se puede especificar una lista de posibles valores e incrementos.

En Fortran y PL/I, la palabra clave DO se usa para lo mismo y se llama do-loop; esto es diferente de un bucle do- while.

PARA

Una instrucción de bucle for está disponible en la mayoría de los lenguajes de programación imperativos. Incluso ignorando diferencias menores en la sintaxis, existen muchas diferencias en cómo funcionan estas declaraciones y el nivel de expresividad que soportan. Generalmente, los bucles for se clasifican en una de las siguientes categorías:

Bucles for tradicionales

El bucle for de lenguajes como ALGOL, Simula, BASIC, Pascal, Modula, Oberon, Ada, Matlab, Ocaml, F#, etc., requiere una variable de control con valores iniciales y finales, que se parece a este:

para i = primero a último do declaración(* o simplemente *)para i = primero..último do declaración

Dependiendo del idioma, se puede usar un signo de asignación explícito en lugar del signo igual (y algunos idiomas requieren la palabra int incluso en el caso numérico). También se puede incluir un valor de paso opcional (un incremento o decremento ≠ 1), aunque la sintaxis exacta utilizada para esto difiere un poco más entre los idiomas. Algunos lenguajes requieren una declaración separada de la variable de control, otros no.

Otra forma fue popularizada por el lenguaje de programación C. Requiere 3 partes: la inicialización (variante de bucle), la condición y el avance a la siguiente iteración. Estas tres partes son opcionales. Este tipo de "bucles de punto y coma" Proviene del lenguaje de programación B y fue inventado originalmente por Stephen Johnson.

En la parte de inicialización, se declaran las variables necesarias (y generalmente se les asignan valores). Si se declaran varias variables, todas deben ser del mismo tipo. La parte de condición verifica una determinada condición y sale del bucle si es falsa, incluso si el bucle nunca se ejecuta. Si la condición es verdadera, se ejecutan las líneas de código dentro del bucle. El avance a la siguiente parte de la iteración se realiza exactamente una vez cada vez que finaliza el ciclo. Luego, el ciclo se repite si la condición se evalúa como verdadera.

Aquí se muestra un ejemplo del bucle for tradicional estilo C en Java.

// Imprime los números de 0 a 99 (y no 100), cada uno seguido por un espacio. para ()int i=0; i.100; i++) {} Sistema.Fuera..impresión()i); Sistema.Fuera..impresión()');}Sistema.Fuera..println();

Estos bucles a veces también se denominan bucles for numéricos en comparación con los bucles foreach (ver más abajo).

Bucles for basados en iteradores

Este tipo de bucle for es una generalización del tipo de bucle for de rango numérico, ya que permite la enumeración de conjuntos de elementos distintos de secuencias numéricas. Generalmente se caracteriza por el uso de un iterador implícito o explícito, en el que la variable de bucle toma cada uno de los valores de una secuencia u otra colección de datos. Un ejemplo representativo en Python es:

para Tema dentro algunos_iterable_object: algo() Do_something_else()

Donde some_iterable_object es una colección de datos que admite iteración implícita (como una lista de nombres de empleados) o, de hecho, puede ser un iterador en sí. Algunos idiomas tienen esto además de otra sintaxis de bucle for; En particular, PHP tiene este tipo de bucle bajo el nombre para cada, así como un bucle for de tres expresiones (ver más abajo) bajo el nombre para.

Vectorize for-loops

Algunos lenguajes ofrecen un bucle for que actúa como si procesara todas las iteraciones en paralelo, como el for all palabra clave en FORTRAN 95 que tiene la interpretación de que todas las expresiones del lado derecho se evalúan antes de que se realicen cualquier asignación. realizado, a diferencia de la forma de iteración explícita. Por ejemplo, en la instrucción for en el siguiente pseudocódigo fragmento, al calcular el nuevo valor para A(i), excepto el primero (con i = 2) la referencia a A(i - 1) obtener el nuevo valor que se había colocado allí en el paso anterior. Sin embargo, en la versión para todos, cada cálculo se refiere solo al A original e inalterado.

para i:= 2: N - 1 do A(i):= [A(i - 1) + A(i) + A(i +1)] / 3; siguiente i)
para todos i:= 2: N - 1 do A(i):= [A(i - 1) + A(i) + A(i +1)] / 3;

La diferencia puede ser significativa.

Algunos lenguajes (como FORTRAN 95, PL/I) también ofrecen declaraciones de asignación de matrices, que permiten omitir muchos bucles for. Por lo tanto, un pseudocódigo como A:= 0; establecería todos los elementos de la matriz A a cero, sin importar su tamaño o dimensionalidad. El bucle de ejemplo podría representarse como

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

Pero si eso se representaría en el estilo del bucle for o del bucle for all o algo más, es posible que no se describa claramente en el manual del compilador.

Bucles for compuestos

Introducido con ALGOL 68 y seguido por PL/I, esto permite combinar la iteración de un bucle con una prueba, como en

para i:= 1: N mientras A(i) 0 do etc.

Es decir, se asigna un valor a la variable del bucle i y sólo si la expresión while es verdadera se ejecutará el cuerpo del bucle.. Si el resultado fuera falso, la ejecución del bucle for se detiene en seco. Suponiendo que el valor de la variable de bucle está definido después de la terminación del bucle, entonces la declaración anterior encontrará el primer elemento no positivo en la matriz A (y si no existe tal, su valor será N + 1), o, con las variaciones adecuadas, el primer carácter que no esté en blanco en una cadena, y así sucesivamente.

Contadores de bucles

En programación de computadoras, un contador de bucles es una variable de control que controla las iteraciones de un bucle (una construcción del lenguaje de programación de computadoras). Se llama así porque la mayoría de los usos de esta construcción dan como resultado que la variable tome un rango de valores enteros en algunas secuencias ordenadas (por ejemplo, comenzando en 0 y terminando en 10 en incrementos de 1).

Los contadores de bucle cambian con cada iteración de un bucle, proporcionando un valor único para cada iteración individual. El contador de bucle se utiliza para decidir cuándo debe terminar el bucle y para que el flujo del programa continúe con la siguiente instrucción después del bucle.

Una convención de nomenclatura de identificadores común es que el contador de bucle utilice los nombres de variables i, j y k (y así sucesivamente si necesario), donde i sería el bucle más externo, j el siguiente bucle interno, etc. Algunos programadores también utilizan el orden inverso. En general, se acepta que este estilo se originó en la programación temprana de Fortran, donde estos nombres de variables que comenzaban con estas letras se declaraban implícitamente como de tipo entero, por lo que eran opciones obvias para contadores de bucles que solo se requerían temporalmente. La práctica se remonta a la notación matemática, donde los índices para sumas y multiplicaciones suelen ser i, j, etc. Una convención variante es el uso de letras duplicadas para el índice, ii, jj y kk, ya que esto permite buscar y reemplazar búsquedas más fácilmente que usar una sola letra.

Ejemplo

Un ejemplo de código C que involucra bucles for anidados, donde las variables del contador de bucle son i y j:

para ()i = 0; i . 100; i++) {} para ()j = i; j . 10; j++) {} algunos_función()i, j); }}

Los bucles For en C también se pueden utilizar para imprimir el reverso de una palabra. Como:

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

Aquí, si la entrada es apple, la salida será elppa.

Semántica y construcciones adicionales

Usar como bucles infinitos

Este bucle for estilo C suele ser el origen de un bucle infinito, ya que los pasos fundamentales de la iteración están completamente bajo el control del programador. De hecho, cuando se pretende realizar bucles infinitos, se puede utilizar este tipo de bucle for (con expresiones vacías), como por ejemplo:

para (;) //loop body

Este estilo se utiliza en lugar de infinito mientras (1) bucles para evitar una advertencia de conversión de tipo en algunos compiladores de C/C++. Algunos programadores prefieren la forma más concisa for (;) sobre el semánticamente equivalente pero más detallado while (true) forma.

Salida anticipada y continuación

Algunos lenguajes también pueden proporcionar otras declaraciones de respaldo, que cuando están presentes pueden alterar la forma en que se desarrolla la iteración del bucle for. Entre ellas, las más comunes son las declaraciones de interrupción y continuación que se encuentran en C y sus derivados. La instrucción break hace que el bucle más interno finalice inmediatamente cuando se ejecuta. La declaración de continuación pasará inmediatamente a la siguiente iteración sin avanzar más a través del cuerpo del bucle para la iteración actual. Una declaración for también termina cuando se ejecuta una declaración break, goto o return dentro del cuerpo de la declaración. [Pozos] Otros idiomas pueden tener declaraciones similares o proporcionar medios para alterar el progreso del bucle; por ejemplo en FORTRAN 95:

Sí. I = 1, N declaraciones ! Ejecutado para todos los valores de "I", hasta un desastre si los hay. IF ()no Bien.) CYCLE ! Skip this value of "I", continue with the next. declaraciones ! Ejecutado sólo donde prevalece la bondad. IF ()desastre) EXIT ! Abandona el bucle. declaraciones ! Mientras que bueno y, sin desastre.FIN ! Debería alinearse con el "DO".

Algunos lenguajes ofrecen funciones adicionales, como nombrar las distintas sentencias de bucle, de modo que con múltiples bucles anidados no haya dudas sobre qué bucle está involucrado. Fortran 95, por ejemplo:

X1:Sí. I = 1,N declaraciones X2:Sí. J = 1,M declaraciones IF ()problemas) CYCLE X1 declaraciones FIN X2 declaraciones FIN X1

Por lo tanto, cuando hay un "problema" se detecta en el bucle interno, el CICLO X1 (no X2) significa que el salto será a la siguiente iteración para I, no J. El compilador también verificará que cada END DO tenga el valor apropiado etiqueta para su posición: esto no es sólo una ayuda para la documentación. El programador aún debe codificar el problema correctamente, pero se bloquearán algunos posibles errores.

Alcance y semántica de la variable de bucle

Diferentes idiomas especifican diferentes reglas sobre qué valor mantendrá la variable del bucle al finalizar su bucle y, de hecho, algunos sostienen que "se vuelve indefinido". Esto permite que un compilador genere código que deje cualquier valor en la variable del bucle, o tal vez incluso lo deje sin cambios porque el valor del bucle se mantuvo en un registro y nunca se almacenó en la memoria. El comportamiento real puede incluso variar según la configuración de optimización del compilador, como ocurre con el compilador Honywell Fortran66.

En algunos lenguajes (no C o C++) la variable del bucle es inmutable dentro del alcance del cuerpo del bucle, y cualquier intento de modificar su valor se considera un error semántico. Estas modificaciones a veces son consecuencia de un error del programador, que puede ser muy difícil de identificar una vez realizado. Sin embargo, es probable que el compilador sólo detecte cambios evidentes. Las situaciones en las que la dirección de la variable del bucle se pasa como argumento a una subrutina hacen que sea muy difícil de comprobar, porque el comportamiento de la rutina es, en general, desconocido para el compilador. Algunos ejemplos al estilo de Fortran:

Sí. I = 1, N I = 7 ! Ajuste excesivo de la variable de bucle. Probablemente. Z = ADJUST()I) ! La función "ADJUST" podría alterar "I", a un efecto incierto. normal declaraciones ! La memoria podría desvanecer que "yo" es la variable de bucle. PRINT ()A()I), B()I), I = 1, N, 2) ! Implícito para imprimir elementos extraños de los arrays A y B, reutilizando "I"... PRINT I ! ¿Qué valor se presentará?FIN ! ¿Cuántas veces se ejecutará el bucle?

Un enfoque común es calcular el recuento de iteraciones al inicio de un bucle (con especial atención al desbordamiento como en for i:= 0: 65535 do...; en aritmética de enteros de dieciséis bits) y con cada iteración disminuye este recuento y al mismo tiempo ajusta el valor de I: resultados de doble conteo. Sin embargo, los ajustes al valor de I dentro del bucle no cambiarán el número de iteraciones ejecutadas.

Otra posibilidad más es que el código generado pueda emplear una variable auxiliar como variable de bucle, posiblemente mantenida en un registro de máquina, cuyo valor puede copiarse o no a I en cada iteración. Nuevamente, las modificaciones de I no afectarían el control del bucle, pero ahora es posible una disyunción: dentro del bucle, referencias al valor de I podría corresponder al valor actual (posiblemente alterado) de I o a la variable auxiliar (mantenida a salvo de modificaciones inadecuadas) y se garantizan resultados confusos. Por ejemplo, dentro del bucle, una referencia al elemento I de una matriz probablemente emplearía la variable auxiliar (especialmente si estuviera contenida en un registro de máquina), pero si I es un parámetro para alguna rutina (por ejemplo, una declaración print para revelar su valor), probablemente sería una referencia a la variable adecuada I en su lugar. Lo mejor es evitar tales posibilidades.

Ajuste de límites

Así como la variable índice puede modificarse dentro de un bucle for, también pueden modificarse sus límites y dirección. Pero con un efecto incierto. Un compilador puede impedir tales intentos, puede que no tengan ningún efecto o incluso que funcionen correctamente, aunque muchos declararían que hacerlo sería un error. Considere una afirmación como

para i:= primero: último: paso doA(i):= A(i) / A(last);

Si el enfoque para compilar dicho bucle fuera la evaluación de primero, último y paso y el cálculo de un recuento de iteraciones mediante algo como (last - first)/step una vez solo al principio, entonces, si esos elementos fueran variables simples y sus valores se ajustaran de alguna manera durante las iteraciones, esto no tendría ningún efecto en el recuento de iteraciones incluso si el elemento seleccionado para la división por A(last) cambió.

Lista de rangos de valores

PL/I y Algol 68 permiten bucles en los que la variable del bucle se itera sobre una lista de rangos de valores en lugar de un solo rango. El siguiente ejemplo de PL/I ejecutará el bucle con seis valores de i: 1, 7, 12, 13, 14, 15:

do i = 1, 7, 12 a 15; /*declaraciones*final;

Equivalencia con bucles while

Un bucle for es generalmente equivalente a un bucle while:

factorial:= 1
para contador de 2 a 5
factorial:= factorial * contador
contador:= contador - 1
grabador + "! iguales " + factorial

es equivalente a:

factorial:= 1
contra:= 1
en contra
contador:= contador + 1
factorial:= factorial * contador
grabador + "! iguales " + factorial

como lo demuestra la salida de las variables.

Cronología de la sintaxis del bucle for en varios lenguajes de programación

Dada una acción que debe repetirse, por ejemplo, cinco veces, diferentes idiomas' Los bucles for se escribirán de forma diferente. La sintaxis de un bucle for de tres expresiones es casi idéntica en todos los lenguajes que lo tienen, después de tener en cuenta diferentes estilos de terminación de bloque, etc.

1957: FORTRAN

El equivalente en Fortran del bucle for es el bucle DO, usando la palabra clave do en lugar de for, La sintaxis del bucle DO de Fortran es:

   Sí. etiqueta contra = primero, último, paso   declaracionesetiqueta  declaración

Los siguientes dos ejemplos se comportan de manera equivalente al bucle for de tres argumentos en otros idiomas. inicializando la variable del contador a 1, incrementando en 1 cada iteración del ciclo y deteniéndose en cinco (inclusive).

   Sí. 9, COUNTER = 1, 5, 1   WRITE ()6,8) COUNTER 8  FORMAT() I2 ) 9  CONTINUACIÓN

En Fortran 77 (o posterior), esto también se puede escribir como:

do contra = 1, 5 escribir()*, "(i2)") contrafinal do

La parte del paso puede omitirse si el paso es uno. Ejemplo:

* Ejemplo de bucle.   PROGRAMA MAIN   SUM SQ = 0   Sí. 199 I = 1, 9999   IF ()SUM SQ.GT.1000) Vamos. TO 200199   SUM SQ = SUM SQ + I#2200   PRINT 206, SUMSQ206   FORMAT() I2 )   FIN

Los espacios son irrelevantes en declaraciones Fortran de forma fija, por lo tanto SUM SQ es lo mismo que SUMSQ. En el estilo moderno de Fortran de forma libre, los espacios en blanco son importantes.

In Fortran 90, the GOTO may be avoided by using an EXIT statement.

* Ejemplo de bucle.   programa principal   implícita   entero :: sumsq   entero :: i   sumsq = 0   do i = 1, 9999   si ()sumsq ■ 1000,0) Salida   sumsq = sumsq + i#2   final do   impresión *, sumsq   programa final

1958: ALGOL

ALGOL 58 introdujo la declaración for, usando el formulario como Superplan:

 PARA Identifier = Base ()Diferencia) Límite

For example to print 0 to 10 increment by 1:

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

1960: COBOL

COBOL se formalizó a finales de 1959 y ha tenido muchas elaboraciones. Utiliza el verbo PERFORM que tiene muchas opciones. Originalmente, todos los bucles tenían que estar fuera de línea y el código iterado ocupaba un párrafo separado. Ignorando la necesidad de declarar e inicializar variables, el equivalente COBOL de un bucle for sería.

 PERFORMA SQ-ROUTINE VARYING I DESDE 1 BY 1 UNTIL I ■ 1000 SQ-ROUTINE  ADD I#2 TO SUM-SQ.

En la década de 1980, la adición de bucles en línea y bucles "estructurados" declaraciones como END-PERFORM dieron como resultado un bucle for con una estructura más familiar.

 PERFORMA VARYING I DESDE 1 BY 1 UNTIL I ■ 1000 ADD I#2 TO SUM-SQ. END-PERFORM

Si el verbo PERFORM tiene la cláusula opcional TEST AFTER, el bucle resultante es ligeramente diferente: el cuerpo del bucle se ejecuta al menos una vez, antes de cualquier prueba.

1964: BÁSICA

Los bucles en BASIC a veces se denominan bucles for-next.

10 REM EST FOR LOOP PRINTS ODD NUMBERs from 1 to 1520 PARA I = 1 TO 15 STEP 230 PRINT I40 NEXT I

Observe que el marcador de final de bucle especifica el nombre de la variable de índice, que debe corresponder al nombre de la variable de índice al inicio del bucle for. Algunos lenguajes (PL/I, FORTRAN 95 y posteriores) permiten una etiqueta de declaración al inicio de un bucle for que el compilador puede comparar con el mismo texto en la declaración de final de bucle correspondiente. Fortran también permite EXIT y CYCLE declaraciones para nombrar este texto; en un nido de bucles esto deja claro qué bucle se pretende. Sin embargo, en estos lenguajes las etiquetas deben ser únicas, por lo que los bucles sucesivos que involucran la misma variable de índice no pueden usar el mismo texto ni una etiqueta puede ser el mismo que el nombre de una variable, como la variable de índice del bucle.

1964: PL/I

do contra = 1 a 5 por 1; /* "por 1" es el predeterminado si no especificado */ /*declaraciones*; final;

La instrucción LEAVE se puede utilizar para salir del bucle. Los bucles se pueden etiquetar y dejar puede dejar un bucle etiquetado específico en un grupo de bucles anidados. Algunos dialectos PL/I incluyen la instrucción ITERATE para finalizar la iteración del bucle actual y comenzar la siguiente.

1968: Algol 68

ALGOL 68 tiene lo que se consideraba el bucle universal, la sintaxis completa es:

PARA I DESDE 1 DE 2 A 3 LO QUE IZADA4 DO

Además, el rango de iteración única podría reemplazarse por una lista de dichos rangos. Hay varios aspectos inusuales de la construcción.

• sólo el do ~ od porción era obligatoria, en cuyo caso el bucle se iterará indefinidamente.
• así la cláusula to 100 do ~ od, se iterará exactamente 100 veces.
• el while elemento sintáctico permitió a un programador romper de un for bucle temprano, como en:

INT sum sq:= 0;
Para mí
WHILE
print("Hasta ahora:", i, nueva línea)); # Interpuesto para fines de rastreo. #
# This is the test for the WHILE #
Sí.
suma sq +:= i↑2
OD

Las extensiones posteriores al estándar Algol68 permitieron el to elemento sintáctico que se sustituirá por upto y downto para lograr una pequeña optimización. Los mismos compiladores también incorporaron:

until

para la terminación tardía del bucle.

foreach

para trabajar en arrays en paralelo.

1970: Pascal

para Contrato := 1 a 5 do (*estado financiero*);

Disminuir (contar hacia atrás) es usar downto palabra clave en lugar de to, como en:

para Contrato := 5 abajo 1 do (*estado financiero*);

El bucle for de rango numérico varía algo más.

1972: C/C++

para ()inicialización; condición; aumento/decremento) declaración

La declaración es a menudo una declaración de bloque; un ejemplo de esto sería:

//Usando para-loops para añadir números 1 - 5int suma = 0;para ()int i = 1; i . 5; ++i) {} suma += i;}

La publicación ISO/IEC 9899:1999 (comúnmente conocida como C99) también permite declaraciones iniciales en for bucles. Las tres secciones del bucle for son opcionales, con una condición vacía equivalente a verdadero.

1972: Charla trivial

1 a: 5 hacer: [ :contra Silencio "estados" ]

A diferencia de otros lenguajes, en Smalltalk un bucle for no es una construcción del lenguaje, sino que se define en la clase Número como un método con dos parámetros, el valor final y un cierre, utilizando self como valor inicial.

1980: Ada

para Contrato dentro 1 .. 5 bucle - Declaracionesfinal bucle;

La instrucción exit se puede utilizar para salir del bucle. Los bucles se pueden etiquetar y exit puede dejar un bucle específicamente etiquetado en un grupo de bucles anidados:

Contando: para Contrato dentro 1 .. 5 bucle Triángulo: para Secundaria_Index dentro 2 .. Contrato bucle - Declaraciones Salida Contando; - Declaraciones final bucle Triángulo; final bucle Contando;

1980: Arce

Maple tiene dos formas de bucle for, una para iterar un rango de valores y la otra para iterar sobre el contenido de un contenedor. La forma del rango de valores es la siguiente:

para i desde f por b a t mientras w do # Loop bodyOd;

Todas las partes excepto do y od son opcionales. La parte for i, si está presente, debe ir primero. Las partes restantes (de f, by b, a t, mientras w) puede aparecer en cualquier orden.

La iteración sobre un contenedor se realiza utilizando esta forma de bucle:

para e dentro c mientras w do # Loop bodyOd;

La cláusula in c especifica el contenedor, que puede ser una lista, conjunto, suma, producto, función no evaluada, matriz o un objeto que implementa un iterador.

A for-loop may be terminated by and, end, or end do.

1982: Máxima CAS

En Maxima CAS también se pueden utilizar valores no enteros:

para x:0.5 paso 0.1 thru 0.9 do /* "Haz algo con x" */

1982: PostScript

El bucle for, escrito como [inicial] [incremento ] [límite] {... } for inicializa una variable interna, ejecuta el cuerpo siempre que la variable interna no supere el límite (o no sea menor, si el incremento es negativo) y, al final de cada iteración, incrementa la variable interna. Antes de cada iteración, el valor de la variable interna se coloca en la pila.

1 1 6 {}DECLARACIONES} para

También hay un bucle de repetición simple. El bucle de repetición, escrito como X {... } repetir, repite el cuerpo exactamente X veces.

5 {} DECLARACIONES } repetición

1983: Ada 83 y superiores

procedimiento Main es Sum_Sq : Integer := 0;comenzar para I dentro 1 .. 9999 bucle si Sum_Sq . 1000 entonces Sum_Sq := Sum_Sq + I#2 final si; final bucle;final;

1984: MATLAB

para n = 1:5  -- declaracionesfinal

Después del bucle, n sería 5 en este ejemplo.

Como i se utiliza para la unidad imaginaria, se desaconseja su uso como variable de bucle.

1987: Perl

para ()Cuenta de $ = 1; Cuenta de $ . 5; Cuenta de $++) {} # implícitamente o predefinida variable # Declaraciones;}para ()# Cuenta de $ = 1; Cuenta de $ . 5; Cuenta de $++) {} # variable privada al bucle # Declaraciones;}para ()1..5) {} # variable implícitamente llamada $_; 1..5 crea una lista de estos 5 elementos # Declaraciones;}declaración para 1..5; # casi el mismo (sólo 1 declaración) con el orden del idioma naturalpara # Cuenta de $ ()1..5) {} # variable privada al bucle # Declaraciones;}

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

Para[x= 0 , x . 1, x += 0.1, f[x]]

# First formpara i dentro 1 2 3 4 5do # Debe tener al menos un comando en el bucle eco $i # Just print value of ihecho

# Segunda formapara () i = 1; i .= 5; i++ )do # Debe tener al menos un comando en el bucle eco $i # Just print value of ihecho

forM_ [1..5] $ indx - do declaraciones

statements_result_list . forM [1..5] $ indx - do declaraciones

importación Control.Monad como MparaLoopM_ :: Monad m = a - ()a - Bool) - ()a - a) - ()a - m ()) - m ()paraLoopM_ indx prop incr f = do f indx M.cuando ()prop siguiente) $ paraLoopM_ siguiente prop incr f Donde  siguiente = incr indx

 paraLoopM_ ()0::Int) (). Len) ()+1) $ indx - do - lo que sea con el índice

PARA Contrato := 1 TO 5 Sí. (* secuencia de declaración *)FIN

para i dentro rango()1, 6): # da valores de 1 a 5 inclusive (pero no 6) # Declaraciones # impresión()i)# Si queremos 6 debemos hacer lo siguientepara i dentro rango()1, 6 + 1): # da valores de 1 a 6 # Declaraciones # impresión()i)

repetición con i desde 1 a 5- Declaracioneslog ifinal repetición

set x a {}1, "waffles", "bacon", 5.1, falso}repetición con i dentro xlog ifinal repetición

para i = Empieza, Para, intervalo do - Declaracionesfinal

para i = 1, 5, 2 do impresión()i)final

1 3 5

ipairs()

pares()

para Nombre, teléfono, dirección dentro Contacto() do -- contactos() debe ser una función iteradorfinal

para ()i = 1; i . 5; i++) {}// Declaraciones}

para ()i dentro [1,2,3,4,5]) {}// Declaraciones}

bucle índice="i" lista="1;2,3;4,5" delimitadores=", {}// Declaraciones}

▪cfloop índice="i" desde="1" a="5"■- declaraciones ---▪/cfloop

▪cfloop índice="i" array="#[1,2,3,4,5]#"■- declaraciones ---▪/cfloop

▪cfloop índice="i" lista="1;2,3;4,5" delimitadores=",■- declaraciones ---▪/cfloop

para ()int i = 0; i . 5; i++) {} //performe funciones dentro del bucle; //puede utilizar la declaración 'romper;' para salir temprano; //puede utilizar la declaración 'continua;' para saltar la iteración actual}

para ()Var i = 0; i . 5; i++) {} //...}

para ()Var clave dentro array) {} // también trabaja para assoc. arrays // array de uso[key] ...}

para ()$i = 0; $i . 5; $i++) {} para ()$j = 0; $j . $i; $j++) {} eco "*; } eco "Seguido"n";}

para contra dentro 1..5 # Declaraciones #final5.veces do SilenciocontraSilencio # counter iterates from 0 to 4 # Declaraciones #final1.arriba()5) do SilenciocontraSilencio # Declaraciones #final

 (* for_statement:= "for" ident '=' expr ("to" ❌ "downto") expr "do" expr "done" *)para i = 1 a 5 do (* declaraciones *) hecho ;para j = 5 abajo 0 do (* declaraciones *) hecho ;

para ()Var contra:Uint = 1; contra . 5; contra++) {} //establecimiento;}

Para i = 1 A 10 DeclaracionesEndFor

para i dentro 5 .. 10: # Declaraciones #

para i := 0; i . 10; i++ {} // Declaraciones}

para i dentro 0..10 {} // Declaraciones}

para j = 1:10 # Declaraciones #final