En bucle - For loop
| Construcciones de bucle |
|---|
En informática , un bucle for (o simplemente bucle for ) es una declaración de flujo de control para especificar la iteración , lo que permite que el código se ejecute repetidamente. Se utilizan varias palabras clave para especificar esta declaración: los descendientes de ALGOL utilizan "para", mientras que los descendientes de Fortran utilizan "hacer". Hay otras posibilidades, por ejemplo COBOL que usa "PERFORM VARYING".
Un bucle for tiene dos partes: un encabezado que especifica la iteración y un cuerpo que se ejecuta una vez por iteración. El encabezado a menudo declara un contador de bucle explícito o una variable de bucle, lo que 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 formas abreviadas de bucles while que incrementan y prueban una variable de bucle.
El nombre for-loop proviene de la palabra for , que se usa como palabra clave en muchos lenguajes de programación para introducir un for-loop. El término en inglés data de ALGOL 58 y se popularizó en el influyente posterior ALGOL 60 ; es la traducción directa del alemán anterior für , utilizado en Superplan (1949-1951) por Heinz Rutishauser , quien también participó en la definición de ALGOL 58 y ALGOL 60. El cuerpo del bucle se ejecuta "para" los valores dados de la variable del bucle , aunque esto es más explícito en la versión ALGOL de la declaración, en la que se puede especificar una lista de posibles valores y / o 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 ciclo do-while .
POR
Una declaración de bucle for está disponible en la mayoría de los lenguajes de programación imperativos . Incluso ignorando pequeñas diferencias en la sintaxis, existen muchas diferencias en cómo funcionan estas declaraciones y el nivel de expresividad que apoyan. Generalmente, los bucles for pertenecen a 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 y se parece a esto:
for i = first to last do statement
(* or just *)
for i = first..last do statement
Dependiendo del idioma, se puede usar un signo de asignación explícita en lugar del signo igual (y algunos idiomas requieren la palabra intincluso 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 popularizado 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. Todas estas tres partes son opcionales. Este tipo de "bucles de punto y coma" provino del lenguaje de programación B y fue originalmente inventado por Stephen Johnson .
En la parte de inicialización, se declaran todas las variables necesarias (y normalmente se 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. El avance a la siguiente parte de 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.
A continuación se muestra un ejemplo del bucle for tradicional de estilo C en 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();
Estos bucles también se denominan a veces bucles for numéricos cuando se contrastan con bucles foreach (ver más abajo).
Bucles for basados en iteradores
Este tipo de bucle for es una generalización del tipo de rango numérico de bucle for, ya que permite la enumeración de conjuntos de elementos distintos de las secuencias numéricas. Por lo general, 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 recopilación de datos. Un ejemplo representativo en Python es:
for item in some_iterable_object:
do_something()
do_something_else()
¿Dónde some_iterable_objectes una recopilación de datos que admite la iteración implícita (como una lista de nombres de empleados) o, de hecho, 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 debajo del nombre for each, así como un bucle for de tres expresiones (ver más abajo) debajo del nombre for.
Bucles for vectorizados
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 realizar cualquier asignación, a diferencia de la iteración explícita formulario. Por ejemplo, en la fordeclaración del siguiente fragmento de pseudocódigo, al calcular el nuevo valor de A(i), excepto el primero (con i = 2) la referencia a, A(i - 1)se 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.
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;
La diferencia puede ser significativa.
Algunos lenguajes (como FORTRAN 95, PL / I) también ofrecen instrucciones 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 en cero, sin importar su tamaño o dimensionalidad. El bucle de ejemplo se podría representar 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, puede que no se describa claramente en el manual del compilador.
Bucles for compuestos
Introducido con ALGOL 68 y seguido de PL / I , esto permite que la iteración de un bucle se componga con una prueba, como en
for i := 1 : N while A(i) > 0 do etc.
Es decir, se asigna un valor a la variable de ciclo i y solo si la expresión while es verdadera , se ejecutará el cuerpo del ciclo. Si el resultado fuera falso, la ejecución del bucle for se detiene en seco. Concedido 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 es así, su valor será N + 1 ), o, con variaciones adecuadas , el primer carácter que no está en blanco en una cadena, y así sucesivamente.
Contadores de bucle
En la programación de computadoras, un contador de bucles es la variable 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 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, 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 común de nomenclatura de identificadores es que el contador de bucles use los nombres de variables 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. El orden inverso es también utilizado por algunos programadores. En general, se acepta que este estilo se originó en la programación inicial de FORTRAN , donde estos nombres de variables que comienzan con estas letras se declararon implícitamente que tienen un tipo entero, por lo que eran opciones obvias para los contadores de bucle que solo se requerían temporalmente. La práctica se remonta más allá a la notación matemática donde los índices para sumas y multiplicaciones son a menudo 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 buscar más fácilmente. reemplazar que usar una sola letra.
Ejemplo
Un ejemplo de código C que involucra bucles for anidados, donde las variables del contador de bucles son i y j :
for (i = 0; i < 100; i++) {
for (j = i; j < 10; j++) {
some_function(i, j);
}
}
Se ha demostrado que un bucle for anidado, como en el ejemplo anterior, realiza más cálculos por unidad de tiempo que un bucle sin él. Esta optimización independiente de la máquina significa que el ciclo for anidado terminará más rápido, dado el mismo número de cálculos para realizar. Esta es una ventaja que tiene el bucle for anidado sobre el bucle while anidado, que se comporta de manera diferente.
Los bucles for en C también se pueden utilizar para imprimir el reverso de una palabra. Como:
for (i = 0; i < 6; i++) {
scanf("%c", &a[i]);
}
for (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 de estilo C es comúnmente 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 bucles infinitos, se puede usar este tipo de bucle for (con expresiones vacías), como:
for (;;)
//loop body
Este estilo se usa en lugar de while (1)bucles infinitos para evitar una advertencia de conversión de tipo en algunos compiladores de C / C ++. Algunos programadores prefieren la forma más sucinta for (;;)a la semánticamente equivalente pero más detallada while (true).
Salida anticipada y continuación
Algunos lenguajes también pueden proporcionar otras declaraciones de apoyo, que cuando están presentes pueden alterar cómo procede la iteración del ciclo for. Entre ellos, son comunes las declaraciones de ruptura y continuación que se encuentran en C y sus derivados. La sentencia break hace que el bucle más interno finalice inmediatamente cuando se ejecuta. La instrucción continue se moverá inmediatamente a la siguiente iteración sin más progreso a través del cuerpo del bucle para la iteración actual. Una instrucción for también termina cuando se ejecuta una instrucción break, goto o return dentro del cuerpo de la instrucción. [Wells] Otros lenguajes pueden tener declaraciones similares o proporcionar medios para alterar el progreso del ciclo for; por ejemplo en 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".
Algunos lenguajes ofrecen más facilidades, como nombrar las diversas sentencias de bucle, de modo que con múltiples bucles anidados no haya duda de qué bucle está involucrado. Fortran 95, por ejemplo:
X1:DO I = 1,N
statements
X2:DO J = 1,M
statements
IF (trouble) CYCLE X1
statements
END DO X2
statements
END DO X1
Por lo tanto, cuando se detecta un "problema" 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 la etiqueta apropiada por su posición: esto no es solo una ayuda para la documentación. El programador aún debe codificar el problema correctamente, pero se bloquearán algunos posibles errores.
Ámbito y semántica de variables de bucle
Los diferentes lenguajes especifican diferentes reglas sobre el valor que tendrá la variable de ciclo al terminar su ciclo y, de hecho, algunos sostienen que "se vuelve indefinido". Esto permite que un compilador genere código que deja cualquier valor en la variable de ciclo, o quizás incluso lo deja sin cambios porque el valor del ciclo 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 de bucle es inmutable dentro del alcance del cuerpo del bucle, y cualquier intento de modificar su valor se considera un error semántico. A veces, estas modificaciones 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 solo detecte 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 de comprobar, porque el compilador no puede conocer el comportamiento de la rutina en general. Algunos ejemplos al estilo de 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?
Un enfoque común es calcular el recuento de iteraciones al comienzo de un bucle (con especial atención al desbordamiento como en la for i := 0 : 65535 do ... ;aritmética de enteros de dieciséis bits) y con cada iteración disminuir este recuento al tiempo que se ajusta el valor de I : resultados de recuento doble. Sin embargo, los ajustes al valor de I dentro del ciclo 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 contenida 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 oa la variable auxiliar (mantenida 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á la variable auxiliar (especialmente si se mantiene 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 adecuada I en su lugar. Es mejor evitar tales posibilidades.
Ajuste de límites
Así como la variable de índice puede modificarse dentro de un bucle for, también pueden hacerlo sus límites y dirección. Pero con efecto incierto. Un compilador puede evitar tales intentos, es posible que no tengan efecto o incluso que funcionen correctamente, aunque muchos declararían que hacerlo sería incorrecto. Considere una declaración como
for i := first : last : step do A(i) := A(i) / A(last);
Si el enfoque para compilar tal ciclo fuera la evaluación del primero , el último y el paso y el cálculo de un recuento de iteraciones a través de algo así como (last - first)/stepuna sola vez al inicio, entonces si esos elementos fueran variables simples y sus valores se ajustaran de alguna manera durante el proceso. 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)cambia.
Lista de rangos de valores
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 solo rango. El siguiente ejemplo de PL / I ejecutará el ciclo con seis valores de i: 1, 7, 12, 13, 14, 15:
do i = 1, 7, 12 to 15;
/*statements*/
end;
Equivalencia con bucles while
Un bucle for es generalmente equivalente a un bucle while:
factorial := 1
for counter from 2 to 5
factorial := factorial * counter
counter := counter - 1
print counter + "! equals " + factorial
es equivalente a:
factorial := 1
counter := 1
while counter < 5
counter := counter + 1
factorial := factorial * counter
print counter + "! equals " + factorial
como lo demuestra la salida de las variables.
Línea de tiempo de la sintaxis for-loop en varios lenguajes de programación
Dada una acción que debe repetirse, por ejemplo, cinco veces, los bucles for de diferentes idiomas se escribirán de manera diferente. La sintaxis de un bucle for de tres expresiones es casi idéntica en todos los idiomas que la tienen, después de tener en cuenta los diferentes estilos de terminación de bloque, etc.
1957: FORTRAN
El equivalente de Fortran del bucle for es el bucle DO , utilizando la palabra clave do en lugar de for. La sintaxis del bucle DO de Fortran es:
DO label counter = first, last, step
statements
label statement
Los siguientes dos ejemplos se comportan de manera equivalente a los tres argumentos for-loop en otros lenguajes, inicializando la variable de contador a 1, incrementando en 1 cada iteración del ciclo y deteniéndose en cinco (inclusive).
DO 9, COUNTER = 1, 5, 1
WRITE (6,8) COUNTER
8 FORMAT( I2 )
9 CONTINUE
En Fortran 77 (o posterior), esto también se puede escribir como:
do counter = 1, 5
write(*, '(i2)') counter
end do
La parte del escalón se puede omitir si el escalón es uno. Ejemplo:
* 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
Los espacios son irrelevantes en las declaraciones de Fortran de forma fija, por lo que SUM SQ es lo mismo que SUMSQ . En el estilo moderno de Fortran de forma libre, los espacios en blanco son importantes.
En Fortran 90, el GO TO se puede evitar utilizando una instrucción 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 presentó la fordeclaración, utilizando el formulario como Superplan:
FOR Identifier = Base (Difference) Limit
Por ejemplo, para imprimir de 0 a 10 incrementado en 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 con el código iterado ocupando un párrafo separado. Ignorando la necesidad de declarar e inicializar variables, el equivalente COBOL de un bucle for sería.
PERFORM SQ-ROUTINE VARYING I FROM 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 declaraciones "estructuradas" como END-PERFORM dio como resultado un bucle for con una estructura más familiar.
PERFORM VARYING I FROM 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ÁSICO
Los bucles en BASIC a veces se denominan bucles for-next.
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 el marcador de final de ciclo especifica el nombre de la variable de índice, que debe corresponder al nombre de la variable de índice al comienzo del ciclo for. Algunos lenguajes (PL / I, FORTRAN 95 y posteriores) permiten una etiqueta de instrucción en el inicio de un ciclo for que el compilador puede comparar con el mismo texto en la instrucción de ciclo final correspondiente. Fortran también permite que las declaraciones EXITy CYCLEnombren este texto; en un nido 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 igual al nombre de una variable, como la variable de índice para el bucle.
1964: PL / I
do counter = 1 to 5 by 1; /* "by 1" is the default if not specified */
/*statements*/;
end;
La instrucción LEAVE se puede utilizar para salir del ciclo. 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 terminar la iteración del ciclo actual y comenzar la siguiente.
1968: Algol 68
ALGOL 68 tiene lo que se consideró el bucle universal, la sintaxis completa es:
FOR i FROM 1 BY 2 TO 3 WHILE i≠4 DO ~ OD
Además, el rango de iteración única podría reemplazarse por una lista de dichos rangos. Hay varios aspectos inusuales del constructo
- solo la
do ~ odparte era obligatoria, en cuyo caso el ciclo se repetirá indefinidamente. - por lo tanto, la cláusula se
to 100 do ~ odrepetirá exactamente 100 veces. - el
whileelemento sintáctico permitió a un programador salir de unforbucle antes, como en:
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
Las posteriores extensiones del Algol68 estándar permitieron reemplazar el toelemento sintáctico uptoy downtolograr una pequeña optimización. Los mismos compiladores también incorporaron:
until- para la terminación tardía del bucle.
foreach- para trabajar en matrices en paralelo .
1970: Pascal
for Counter := 1 to 5 do
(*statement*);
Disminuir (contando hacia atrás) es usar una downtopalabra clave en lugar de to, como en:
for Counter := 5 downto 1 do
(*statement*);
El bucle for de rango numérico varía algo más.
1972: C / C ++
for (initialization; condition; increment/decrement)
statement
La declaración es a menudo una declaración de bloque; un ejemplo de esto sería:
//Using for-loops to add numbers 1 - 5
int sum = 0;
for (int i = 1; i < 6; ++i) {
sum += i;
}
La publicación ISO / IEC 9899: 1999 (comúnmente conocida como C99 ) también permite declaraciones iniciales en forbucles. Las tres secciones del ciclo for son opcionales.
1972: Smalltalk
1 to: 5 do: [ :counter | "statements" ]
A diferencia de otros lenguajes, en Smalltalk un bucle for no es una construcción de 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
for Counter in 1 .. 5 loop
-- statements
end loop;
La declaración de salida se puede utilizar para salir del ciclo. Los bucles se pueden etiquetar y la salida puede dejar un bucle etiquetado específicamente en un grupo de bucles anidados:
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: arce
Maple tiene dos formas de bucle for, una para iterar de un rango de valores y la otra para iterar sobre el contenido de un contenedor. La forma del rango de valores es la siguiente:
for i from f by b to t while w do
# loop body
od;
Todas las partes excepto doy odson opcionales. La pieza, si está presente, debe ir primero. Las partes restantes ( , , , ) pueden aparecer en cualquier orden.
for ifrom fby bto twhile w
La iteración sobre un contenedor se realiza mediante esta forma de bucle:
for e in c while w do
# loop body
od;
La cláusula especifica el contenedor, que puede ser una lista, conjunto, suma, producto, función no evaluada, matriz o un objeto que implementa un iterador.
in c
A-bucle para puede ser terminado por od, endo end do.
1982: Maxima CAS
En Maxima CAS también se pueden utilizar valores no enteros:
for x:0.5 step 0.1 thru 0.9 do
/* "Do something with x" */
1982: PostScript
El bucle for, escrito como [initial] [increment] [limit] { ... } forinicializa una variable interna, ejecuta el cuerpo siempre que la variable interna no sea más que el límite (o no menos, 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 inserta en la pila.
1 1 6 {STATEMENTS} for
También hay un bucle de repetición simple. El ciclo de repetición, escrito como X { ... } repeat, repite el cuerpo exactamente X veces.
5 { STATEMENTS } repeat
1983: Ada 83 y superior
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
Después del ciclo, nsería 5 en este ejemplo.
Como ise usa para la unidad Imaginary , se desaconseja su uso como variable de bucle.
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;
}
(Tenga en cuenta que " hay más de una forma de hacerlo " es un lema de programación de Perl).
1988: Mathematica
La construcción correspondiente a la mayoría de los otros lenguajes 'for-loop se llama Do en Mathematica
Do[f[x], {x, 0, 1, 0.1}]
Mathematica también tiene una construcción For que imita el ciclo for de lenguajes tipo C
For[x= 0 , x <= 1, x += 0.1,
f[x]
]
1989: Golpe
# 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
Tenga en cuenta que un bucle vacío (es decir, uno sin comandos entre doy done) es un error de sintaxis. Si los bucles anteriores solo contienen comentarios, la ejecución daría como resultado el mensaje "error de sintaxis cerca del token inesperado 'hecho'".
1990: Haskell
El imperativo incorporado forM_ mapea una expresión monádica en una lista, como
forM_ [1..5] $ \indx -> do statements
u obtenga el resultado de cada iteración como una lista en
statements_result_list <- forM [1..5] $ \indx -> do statements
Pero, si desea guardar el espacio de la lista [1..5], una construcción forLoop_ monádica más auténtica se puede definir 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
y utilizado como:
forLoopM_ (0::Int) (< len) (+1) $ \indx -> do -- whatever with the index
1991: Oberon-2, Oberon-07 o Componente Pascal
FOR Counter := 1 TO 5 DO
(* statement sequence *)
END
Tenga en cuenta que en el lenguaje original de Oberon, el bucle for se omitió a favor de la construcción de bucle de Oberon más general. El bucle for se reintrodujo en Oberon-2.
1991: Python
Python no contiene el bucle for clásico, sino que foreachse usa un bucle para iterar sobre la salida de la range()función incorporada que devuelve una lista iterable de enteros.
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)
El uso range(6)ejecutaría el ciclo de 0 a 5.
1993: AppleScript
repeat with i from 1 to 5
-- statements
log i
end repeat
También puede iterar a través de una lista de elementos, similar a lo que puede hacer con matrices en otros idiomas:
set x to {1, "waffles", "bacon", 5.1, false}
repeat with i in x
log i
end repeat
También puede utilizar exit repeatpara 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.
1993: Lua
for i = start, stop, interval do
-- statements
end
Entonces, este código
for i = 1, 5, 2 do
print(i)
end
imprimirá:
1 3 5
Los bucles for también pueden recorrer una tabla usando
ipairs()
para iterar numéricamente a través de matrices y
pairs()
para iterar aleatoriamente a través de diccionarios.
For-loop genérico que utiliza cierres :
for name, phone, address in contacts() do
-- contacts() must be an iterator function
end
1995: CFML
Sintaxis de la secuencia de comandos
Bucle de índice simple:
for (i = 1; i <= 5; i++) {
// statements
}
Usando una matriz:
for (i in [1,2,3,4,5]) {
// statements
}
Usando una lista de valores de cadena:
loop index="i" list="1;2,3;4,5" delimiters=",;" {
// statements
}
El anterior listejemplo sólo está disponible en el dialecto de CFML utilizado por Lucee y Railo .
Sintaxis de la etiqueta
Bucle de índice simple:
<cfloop index="i" from="1" to="5">
<!--- statements --->
</cfloop>
Usando una matriz:
<cfloop index="i" array="#[1,2,3,4,5]#">
<!--- statements --->
</cfloop>
Usando una "lista" de valores de cadena:
<cfloop index="i" list="1;2,3;4,5" delimiters=",;">
<!--- statements --->
</cfloop>
1995: Java
for (int i = 0; i < 5; i++) {
//perform functions within the loop;
//can use the statement 'break;' to exit early;
//can use the statement 'continue;' to skip the current iteration
}
Para el bucle for extendido, consulte Foreach loop § Java .
1995: JavaScript
JavaScript admite bucles de "tres expresiones" de estilo C. Las declaraciones breaky continuese admiten dentro de los bucles.
for (var i = 0; i < 5; i++) {
// ...
}
Alternativamente, es posible iterar sobre todas las claves de una matriz.
for (var key in array) { // also works for assoc. arrays
// use array[key]
...
}
1995: PHP
Esto imprime un triángulo de *
for ($i = 0; $i <= 5; $i++) {
for ($j = 0; $j <= $i; $j++) {
echo "*";
}
echo "<br />\n";
}
1995: Rubí
for counter in 1..5
# statements
end
5.times do |counter| # counter iterates from 0 to 4
# statements
end
1.upto(5) do |counter|
# statements
end
Ruby tiene varias sintaxis posibles, incluidas las muestras anteriores.
1996: OCaml
Consulte la sintaxis de expresiones.
(* for_statement := "for" ident '=' expr ( "to" ∣ "downto" ) expr "do" expr "done" *)
for i = 1 to 5 do
(* statements *)
done ;;
for j = 5 downto 0 do
(* statements *)
done ;;
1998: ActionScript 3
for (var counter:uint = 1; counter <= 5; counter++){
//statement;
}
2008: Pequeño Básico
For i = 1 To 10
' Statements
EndFor
2008: Nim
Nim tiene un foreachbucle -type y varias operaciones para crear iteradores.
for i in 5 .. 10:
# statements
2009: ir
for i := 0; i <= 10; i++ {
// statements
}
2010: óxido
for i in 0..10 {
// statements
}
2012: Julia
for j = 1:10
# statements
end