Bucle for

En informática , un bucle for es una instrucción de flujo de control para especificar una iteración . En concreto, un bucle for funciona ejecutando una sección de código repetidamente hasta que se cumpla 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 permite que el cuerpo sepa qué iteración se está ejecutando. Los bucles for se utilizan normalmente cuando se conoce el número de iteraciones antes de entrar en el 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 utilizan " for ", mientras que los descendientes de Fortran utilizan " do ". Existen otras posibilidades, por ejemplo, COBOL, que utiliza .PERFORM VARYING

El nombre for-loop proviene de la palabra for. For se utiliza como palabra reservada (o 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 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. ^[1] El cuerpo del bucle se ejecuta "para" los valores dados de la variable del bucle. Esto es más explícito en las versiones de 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 denomina bucle do ; es diferente de un bucle do while .

La mayoría de los lenguajes de programación imperativos cuentan con una sentencia de bucle for . Incluso si ignoramos las pequeñas diferencias de sintaxis , existen muchas diferencias en el funcionamiento de estas sentencias y en el nivel de expresividad que admiten. En general, los bucles for se dividen en cuatro categorías:

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 esto:

para i = primera a última declaración do (* o simplemente *) para i = primera .. última declaración do            

Según el idioma, se puede utilizar un signo de asignación explícita en lugar del signo igual (y algunos idiomas requieren la palabra inteven en el caso numérico). También se puede incluir un valor de paso opcional (un incremento o decremento ≠ 1), aunque las sintaxis exactas utilizadas para esto difieren un poco más entre los idiomas. Algunos idiomas requieren una declaración separada de la variable de control, otros no.

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

En la parte de inicialización, se declaran todas las variables necesarias (y normalmente se les asignan valores). Si se declaran varias variables, todas deben ser del mismo tipo. La parte de condición comprueba 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 iteración se realiza exactamente una vez cada vez que finaliza el bucle. Luego, el bucle se repite si la condición se evalúa como verdadera.

A continuación se muestra un ejemplo del bucle for tradicional de estilo C en Java .

// Imprime los números del 0 al 99 (y no 100), cada uno seguido de un espacio.para ( int i = 0 ; i < 100 ; i ++ ) { Sistema . out . print ( i ); Sistema . out . print ( ' ' ); } Sistema . out . println ();      

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

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. Suele caracterizarse por el uso de un iterador implícito o explícito , en el que la variable del bucle toma cada uno de los valores de una secuencia u otro conjunto de datos. Un ejemplo representativo en Python es:

para  el elemento  en  algún_objeto_iterable :  hacer_algo ()  hacer_algo_más ()

Donde some_iterable_objectes una colección de datos que admite la iteración implícita (como una lista de nombres de empleados) o puede ser un iterador en sí mismo. Algunos lenguajes tienen esto además de otra sintaxis de bucle for; en particular, PHP tiene este tipo de bucle bajo el nombre for each, así como un bucle for de tres expresiones (ver a continuación) bajo el nombre for.

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

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

La diferencia puede ser significativa.

Algunos lenguajes (como PL/I, Fortran 95) también ofrecen instrucciones de asignación de matrices, que permiten omitir muchos bucles for. Por lo tanto, un pseudocódigo como este A := 0;establecería todos los elementos de la matriz A en 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 es posible que en el manual del compilador no esté claramente descrito si esto se representará en el estilo del bucle for o del bucle for all o de algún otro modo.

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

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

Es decir, se asigna un valor a la variable de bucle i y solo 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. Suponiendo que el valor de la variable de bucle se define 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 hay tal, su valor será N + 1 ), o, con variaciones adecuadas, el primer carácter que no sea un espacio en blanco en una cadena, y así sucesivamente.

En programación informática , un contador de bucle es una variable de control que controla las iteraciones de un bucle (una construcción del lenguaje de programación informática ). Se llama así porque la mayoría de los usos de esta construcción dan como resultado que la variable adopte 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 y proporcionan 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 nombres de identificadores común es que el contador de bucle use los nombres de variable i , j y k (y así sucesivamente si es necesario), donde i sería el bucle más externo, j el siguiente bucle interno, etc. Algunos programadores también usan el orden inverso. En general, se acepta que este estilo se originó en la programación temprana de Fortran ^{[ cita requerida ]} , donde estos nombres de variable que comienzan con estas letras se declaraban implícitamente como de tipo entero, y por lo tanto eran opciones obvias para los contadores de bucle que solo se requerían temporalmente. La práctica se remonta a la notación matemática donde los índices para sumas y multiplicaciones a menudo son i , j , etc. Una convención variante es el uso de letras duplicadas para el índice, ii , jj y kk , ya que esto permite una búsqueda y reemplazo de búsqueda más fácil que usar una sola letra. ^[4]

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

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

Los bucles for en C también se pueden utilizar para imprimir el reverso de una palabra. Por ejemplo:

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

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

Este bucle for de estilo C suele ser la fuente 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 pretenden crear bucles infinitos, se puede utilizar este tipo de bucle for (con expresiones vacías), como por ejemplo:

para (;;) //cuerpo del bucle  

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

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

DO I = 1 , N declaraciones !Ejecutado para todos los valores de "I", hasta un desastre si lo hay. IF ( no good ) CYCLE !Omitir este valor de "I", continuar con el siguiente. declaraciones !Ejecutado solo donde prevalece lo bueno. IF ( desastre ) EXIT !Abandona el bucle. declaraciones !Mientras sea bueno y no haya desastre. END DO !Debe alinearse con "DO".                   

Algunos lenguajes ofrecen funciones adicionales, como nombrar las distintas sentencias de bucle de modo que, en el caso de varios bucles anidados, no haya dudas sobre cuál de ellos está involucrado. Fortran 95, por ejemplo:

X1 : DO I = 1 , N declaraciones X2 : DO J = 1 , M declaraciones IF ( problema ) CICLO X1 declaraciones FIN DO X2 declaraciones FIN DO X1              

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

Los distintos lenguajes especifican distintas reglas sobre el valor que tendrá la variable de bucle al finalizar el 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 de bucle o, tal vez, incluso la 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 sucede con el compilador Honywell Fortran66.

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

DO I = 1 , N I = 7 !Ajuste manifiesto de la variable de bucle. Posible queja del compilador. Z = ADJUST ( I ) !La función "ADJUST" puede alterar "I", con un efecto incierto. ¡ Declaraciones normales !La memoria puede perder el sentido de que "I" es la variable de bucle. PRINT ( A ( I ), B ( I ), I = 1 , N , 2 ) !Bucle for implícito para imprimir elementos impares de las matrices A y B, reutilizando "I"... PRINT I !¿Qué valor se presentará? END DO !¿Cuántas veces se ejecutará el bucle?                          

Un enfoque común es calcular el recuento de iteraciones al comienzo de un bucle (prestando especial atención al desbordamiento, como en for i := 0 : 65535 do ... ;la aritmética de números enteros de dieciséis bits) y, con cada iteración, disminuir este recuento mientras se ajusta también el valor de I : el resultado es un recuento doble. Sin embargo, los ajustes al valor de I dentro del bucle no cambiarán la cantidad de iteraciones ejecutadas.

Otra posibilidad es que el código generado pueda emplear una variable auxiliar como variable de bucle, posiblemente guardada en un registro de máquina, cuyo valor puede o no copiarse 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, las referencias al valor de I podrían ser al valor actual (posiblemente alterado) de I o a la variable auxiliar (guardada a salvo de modificaciones indebidas) 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 se guardara en un registro de máquina), pero si I es un parámetro para alguna rutina (por ejemplo, una declaración de impresión para revelar su valor), probablemente sería una referencia a la variable apropiada I en su lugar. Es mejor evitar tales posibilidades.

Así como la variable de í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 puede que funcionen correctamente, aunque muchos declararían que hacerlo sería un error. Considere una declaración como

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

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

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

hacer  i = 1 , 7 , 12 a 15 ; /*declaraciones*/ fin ;       

Un bucle for generalmente es equivalente a un bucle while:

factorial := 1 Para el contador del 2 al 5 factorial := factorial * contadorcontador := contador - 1imprimir contador + "! igual a " + factorial

es equivalente a:

factorial := 1contador := 1 mientras contador < 5 contador := contador + 1 factorial := factorial * contadorimprimir contador + "! igual a " + factorial

como lo demuestra el resultado de las variables.

Dada una acción que debe repetirse, por ejemplo, cinco veces, los bucles for de los distintos lenguajes 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 los diferentes estilos de terminación de bloque, etc.

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

   Contador de etiquetas DO = primera , última , paso declaraciones etiqueta declaración          

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

   HACER 9 , CONTADOR = 1 , 5 , 1 ESCRIBIR ( 6 , 8 ) CONTADOR  8 FORMATO ( I2 )  9 CONTINUAR                

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

hacer contador = 1 , 5 escribir ( * , '(i2)' ) contador fin hacer      

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

* Ejemplo de bucle DO. PROGRAMA PRINCIPAL SUMA SQ = 0 DO 199 I = 1 , 9999999 IF ( SUMA SQ . GT . 1000 ) IR A 200 199 SUMA SQ = SUMA SQ + I ** 2 200 IMPRIMIR 206 , SUMAQ 206 FORMATO ( I2 ) FIN                                      

Los espacios son irrelevantes en las instrucciones Fortran de formato fijo, por lo que SUM SQ es lo mismo que SUMSQ . En el estilo Fortran de formato libre moderno, los espacios en blanco son significativos.

En Fortran 90, se puede evitar GO TO utilizando una declaración EXIT .

* Ejemplo de bucle DO. programa principal implícito ninguno         entero :: sumacuadrada entero :: i          sumaq = 0 hacer i = 1 , 9999999 si ( sumaq > 100 0.0 ) salir sumaq = sumaq + i ** 2 fin hacer imprimir * , sumaq                                 Fin del programa

ALGOL 58 presentó la fordeclaración, utilizando la forma Superplan:

PARA Identificador = Base ( Diferencia ) Límite

Por ejemplo, para imprimir del 0 al 10 incrementado en 1:

PARA x = 0 (1) 10 COMIENZAIMPRIMIR (FL) = x FIN

COBOL se formalizó a fines de 1959 y ha tenido muchas modificaciones. 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. Si se ignora la necesidad de declarar e inicializar variables, el equivalente en COBOL de un bucle for sería.

 REALIZAR RUTINA SQ VARIANDO I DE 1 EN 1 HASTA I > 1000          RUTINA-SQ SUMA I ** 2 A SUMA-SQ .    

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

 REALIZAR VARIAR I DE 1 EN 1 HASTA I > 1000 SUMA I ** 2 A SUMA-CUAD . FINAL DE LA EJECUCIÓN            

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.

En BASIC , a un bucle a veces se le denomina bucle for-next .

10 REM ESTE BUCLE FOR IMPRIME NÚMEROS IMPARES DEL 1 AL 15 20 PARA I = 1 A 15 PASO 2 30 IMPRIMIR I 40 SIGUIENTE I             

El marcador de fin de bucle especifica el nombre de la variable de índice, que debe corresponderse con el nombre de la variable de índice en el 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 fin de bucle correspondiente. Fortran también permite que las declaraciones EXITand CYCLEnombren este texto; en un anidamiento de bucles, esto deja en 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 la misma que el nombre de una variable, como la variable de índice para el bucle.

hacer  contador = 1 a 5 en 1 ; /* "en 1" es el valor predeterminado si no se especifica */ /*declaraciones*/ ; fin ;         

La instrucción LEAVE se puede utilizar para salir del bucle. Los bucles se pueden etiquetar como , y leave puede salir de 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 actual del bucle y comenzar la siguiente.

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

PARA i DE 1 POR 2 A 3 MIENTRAS i≠4 HACER ~ OD

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

• Sólo la do ~ odparte era obligatoria, en cuyo caso el bucle se iteraría indefinidamente.
• Por lo tanto, la cláusula to 100 do ~ odse iterará exactamente 100 veces.
• El while elemento sintáctico permitía a un programador salir de un forbucle de forma anticipada, como en:

INT suma cuadrada := 0;Para mí MIENTRAS print(("Hasta ahora:", i, nueva línea)); # Interpuesto para fines de seguimiento. # suma cuadrada ≠ 70↑2 # Esta es la prueba para WHILE #HACER suma cuadrada +:= i↑2sobredosis

Las ampliaciones posteriores del estándar ALGOL 68 permitieron tosustituir el elemento sintáctico por uno nuevo uptoy downtolograr una pequeña optimización. Los mismos compiladores también incorporaron:

until

para terminación tardía del bucle.

foreach

para trabajar en matrices en paralelo .

para Contador := 1 a 5 hacer (*declaración*) ;       

Para decrementar (contar hacia atrás) se utiliza downtola palabra clave en lugar de to, como en:

para Contador := 5 a 1 hacer (*declaración*) ;       

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

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

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

//Usando bucles for para sumar números del 1 al 5 int suma = 0 ; for ( 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 forbucles. Las tres secciones del bucle for son opcionales y una condición vacía equivale a verdadera.

1  a:  5  hacer: [ : contador  |  "declaraciones" ]

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

para  Counter  en  bucle 1  ..  5  -- declaraciones fin bucle  ; 

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

Contando :  para  Contador  en  bucle 1  ..  5  Triángulo  : para Índice_secundario en bucle 2 .. Contador -- las sentencias salen de Contando ; -- las sentencias terminan el bucle Triángulo ; fin del bucle Contando ;                 

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  de  f  por  b  a  t  mientras  w  haga  # cuerpo del bucle od ;

Todas las partes excepto doy odson opcionales. La parte, si está presente, debe aparecer primero. Las partes restantes ( , , , ) pueden aparecer en cualquier orden.for ifrom fby bto twhile w

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

para  e  en  c  mientras  w  hacer  # cuerpo del bucle od ;

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

Un bucle for puede terminarse con od, end, o end do.

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

para x : 0,5 paso 0,1 a 0,9 hacer /* "Hacer algo con x" */       

El bucle for, escrito como [initial] [increment] [limit] { ... } forinicializa una variable interna, ejecuta el cuerpo mientras la variable interna no sea mayor que el límite (o no 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. ^[6]

1  1  6  { DECLARACIONES }  para

También existe un bucle de repetición simple. El bucle de repetición, escrito como X { ... } repeat, repite el cuerpo exactamente X veces. ^[7]

5  {  DECLARACIONES  }  repetir

procedimiento  Principal  es  Sum_Sq  :  Entero  :=  0 ; comenzar  para  I  en  1  ..  9999999  bucle  si  Sum_Sq  <=  1000  entonces  Sum_Sq  :=  Sum_Sq  +  I ** 2  fin  si ;  fin  bucle ; fin ;

para n = 1 : 5 -- fin de las declaraciones     

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

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

for ( $counter = 1 ; $counter <= 5 ; $counter ++ ) { # variable implícita o predefinida # declaraciones; } for ( my $counter = 1 ; $counter <= 5 ; $counter ++ ) { # variable privada del bucle # declaraciones; } for ( 1 .. 5 ) { # variable llamada implícitamente $_; 1..5 crea una lista de estos 5 elementos # declaraciones; } declaración for 1 .. 5 ; # casi lo mismo (solo 1 declaración) con orden de lenguaje natural for my $counter ( 1 .. 5 ) { # variable privada del bucle # declaraciones; }                                  

" Hay más de una manera de hacerlo " es un lema de programación en Perl.

La construcción correspondiente al bucle for de la mayoría de los otros lenguajes se llama Do en Mathematica.

Hacer [ f [ x ] , { x , 0 , 1 , 0 . 1 } ]    

Mathematica también tiene una construcción For que imita el bucle for de los lenguajes tipo C.

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

# primera forma para  i en 1 2 3 4 5 do # debe tener al menos un comando en bucle echo $i # solo imprime el valor de i hecho          

# segunda forma para (( i = 1 ; i < = 5 ; i++ )) do # debe tener al menos un comando en bucle echo $i # solo imprime el valor de i hecho             

Un bucle vacío (es decir, uno sin comandos entre doy done) es un error de sintaxis. Si los bucles anteriores solo contuvieran comentarios, la ejecución generaría el mensaje "error de sintaxis cerca del token inesperado 'done'".

El imperativo incorporado forM_ asigna una expresión monádica a una lista, como

forM_ [ 1 .. 5 ] $ \ indx -> hacer declaraciones      

o obtener cada resultado de iteración como una lista en

lista_resultados_de_declaraciones <- forM [ 1 .. 5 ] $ \ indx -> hacer declaraciones        

Pero, para ahorrar el espacio de la lista [1..5], se puede definir una construcción forLoop_ monádica más auténtica como

Importar Control.Monad como M   forLoopM_ :: Mónada m => a -> ( a -> Bool ) -> ( a -> a ) -> ( a -> m () ) -> m () forLoopM_ indx prop incr f = do f indx M . cuando ( prop siguiente ) $ forLoopM_ siguiente prop incr f donde siguiente = incr indx                                           

y se utiliza como:

 forLoopM_ ( 0 :: Int ) ( < len ) ( + 1 ) $ \ indx -> hacer -- lo que sea con el índice         

PARA  Contador  :=  1  A  5  HACER  (* secuencia de instrucciones *) FIN

En el lenguaje original de Oberon, el bucle for se omitió en favor de la construcción más general de bucle de Oberon. El bucle for se reintrodujo en Oberon-2.

Python no contiene el bucle for clásico, sino que foreachse utiliza un bucle para iterar sobre la salida de la función incorporada range()que devuelve una secuencia iterable de números enteros.

for  i  in  range ( 1 ,  6 ):  # da i valores de 1 a 5 inclusive (pero no 6)  # declaraciones  print ( i ) # si queremos 6 debemos hacer lo siguiente for  i  in  range ( 1 ,  6  +  1 ):  # da i valores de 1 a 6  # declaraciones  print ( i )

Usando range(6)se ejecutaría el bucle de 0 a 5.

repetir  con  i  del  1  al  5 -- declaraciones log  i fin  repetir

También puede iterar a través de una lista de elementos, de forma similar a lo que se puede hacer con matrices en otros lenguajes:

Establezca  x  en  { 1 ,  "waffles" ,  "bacon" ,  5.1 ,  falso } repita  con  i  en  x log  i fin  de repetición

exit repeatTambién se puede utilizar A para salir de un bucle en cualquier momento. A diferencia de otros lenguajes, AppleScript actualmente no tiene ningún comando para continuar con la siguiente iteración de un bucle.

para  i  =  inicio ,  fin ,  intervalo  do  -- sentencias end

Entonces, este código

para  i  =  1 ,  5 ,  2  imprimir  ( i ) fin​

imprimirá:

1  3  5

Los bucles for también pueden recorrer una tabla usando

ipares ()

iterar numéricamente a través de matrices y

pares ()

iterar aleatoriamente a través de diccionarios.

Bucle for genérico que hace uso de cierres:

para  nombre ,  teléfono ,  dirección  en  contactos ()  do  --contactos() debe ser una función iteradora fin

Bucle de índice simple:

para  ( i  =  1 ;  i  <=  5 ;  i ++ )  { // declaraciones }

Usando una matriz:

para  ( i  en  [ 1 , 2 , 3 , 4 , 5 ])  { // declaraciones }

Usando una lista de valores de cadena:

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

El listejemplo anterior solo está disponible en el dialecto de CFML utilizado por Lucee y Railo .

Bucle de índice simple:

<cfloop  índice = "i"  de = "1"  a = "5" > <!--- declaraciones ---> </cfloop>

Usando una matriz:

<cfloop  índice = "i"  matriz = " #[1,2,3,4,5]# " > <!--- declaraciones ---> </cfloop>

Usando una "lista" de valores de cadena:

<cfloop  índice = "i"  lista = "1;2,3;4,5"  delimitadores = ",;" > <!--- declaraciones ---> </cfloop>

for ( int i = 0 ; i < 5 ; i ++ ) { //realizar funciones dentro del bucle; //puede usar la declaración 'break;' para salir antes; //puede usar la declaración 'continue;' para omitir la iteración actual }            

Para el bucle for extendido, consulte Bucle foreach § Java .

JavaScript admite bucles de "tres expresiones" de estilo C. Las instrucciones breaky continuese admiten dentro de los bucles.

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

Alternativamente, es posible iterar sobre todas las claves de una matriz.

para ( var clave en matriz ) { // también funciona para matrices asociativas // usar matriz[clave] ... }        

Esto imprime un triángulo de *

para  ( $i  =  0 ;  $i  <=  5 ;  $i ++ )  {  para  ( $j  =  0 ;  $j  <=  $i ;  $j ++ )  {  echo  "*" ;  }  echo  "<br /> \n " ; }

para contador en 1 .. 5 # declaraciones finales    5. veces do | counter | # contador itera de 0 a 4 # declaraciones end    1 . hasta ( 5 ) hacer | contador | # declaraciones fin   

Ruby tiene varias sintaxis posibles, incluidos los ejemplos anteriores.

Véase sintaxis de expresión. ^[8]

 (* para_declaración := "para" ident '=' expr ( "hasta" ∣ "hasta" ) expr "hacer" expr "hecho" *)para  i  =  1  a  5  hacer  (* declaraciones *)  hecho  ;;para  j  =  5  hasta  0  hacer  (* declaraciones *)  hecho  ;;

para ( var contador : uint = 1 ; contador <= 5 ; contador ++){ //declaración; }         

Para i = 1 a 10 ' Declaraciones FinPara      

Nim tiene un foreachbucle de tipo y varias operaciones para crear iteradores. ^[9]

para i en 5 .. 10 : # declaraciones      

para i := 0 ; i <= 10 ; i ++ { // declaraciones }         

para i en 0 .. 10 { // declaraciones }     

para j = 1 : 10 # declaraciones finales    

• Hacer bucle while
• Para cada uno
• Bucle While
• Función recursiva primitiva
• Función recursiva general