Boucle pour - For loop
| Constructions de boucle |
|---|
En informatique , une boucle for (ou simplement une boucle for ) est une instruction de flux de contrôle pour spécifier l' itération , qui permet au code d'être exécuté de manière répétée. Différents mots-clés sont utilisés pour spécifier cette instruction : les descendants d' ALGOL utilisent "for", tandis que les descendants de Fortran utilisent "do". Il existe d'autres possibilités, par exemple COBOL qui utilise "PERFORM VARYING".
Une boucle for a deux parties : un en-tête spécifiant l'itération et un corps qui est exécuté une fois par itération. L'en-tête déclare souvent un compteur de boucle explicite ou une variable de boucle, qui permet au corps de savoir quelle itération est en cours d'exécution. Les boucles For sont généralement utilisées lorsque le nombre d'itérations est connu avant d'entrer dans la boucle. Les boucles for peuvent être considérées comme des raccourcis pour les boucles while qui incrémentent et testent une variable de boucle.
Le nom for-loop vient du mot for , qui est utilisé comme mot - clé dans de nombreux langages de programmation pour introduire une boucle for. Le terme en anglais remonte à ALGOL 58 et a été popularisé dans le plus tard influent ALGOL 60 ; c'est la traduction directe de l'ancien allemand für , utilisé dans Superplan (1949-1951) par Heinz Rutishauser , qui a également participé à la définition d'ALGOL 58 et ALGOL 60. Le corps de la boucle est exécuté "pour" les valeurs données de la variable de boucle , bien que cela soit plus explicite dans la version ALGOL de l'instruction, dans laquelle une liste de valeurs et/ou d'incréments possibles peut être spécifiée.
En FORTRAN et PL/I , le mot-clé DO est utilisé pour la même chose et s'appelle une boucle do ; c'est différent d'une boucle do-while .
POUR
Une instruction for-loop est disponible dans la plupart des langages de programmation impératifs . Même en ignorant les différences mineures de syntaxe, il existe de nombreuses différences dans le fonctionnement de ces instructions et le niveau d'expressivité qu'elles prennent en charge. Généralement, les boucles for appartiennent à l'une des catégories suivantes :
Boucles for traditionnelles
La boucle for de langages comme ALGOL , Simula , BASIC , Pascal , Modula , Oberon , Ada , Matlab , Ocaml , F# , etc., nécessite une variable de contrôle avec des valeurs de début et de fin et ressemble à ceci :
for i = first to last do statement
(* or just *)
for i = first..last do statement
Selon la langue, un signe d' affectation explicite peut être utilisé à la place du signe égal (et certaines langues nécessitent le mot intmême dans le cas numérique). Une valeur de pas facultative (un incrément ou un décrément ≠ 1) peut également être incluse, bien que les syntaxes exactes utilisées pour cela diffèrent un peu plus entre les langues. Certains langages nécessitent une déclaration séparée de la variable de contrôle, d'autres non.
Une autre forme a été popularisée par le langage de programmation C . Il nécessite 3 parties : l' initialisation ( variante de boucle ), la condition et le passage à l'itération suivante. Ces trois parties sont facultatives. Ce type de "boucles point-virgule" vient du langage de programmation B et a été inventé à l'origine par Stephen Johnson .
Dans la partie initialisation, toutes les variables nécessaires sont déclarées (et généralement des valeurs affectées). Si plusieurs variables sont déclarées, elles doivent toutes être du même type. La partie condition vérifie une certaine condition et quitte la boucle si elle est fausse. Le passage à la partie d'itération suivante est effectué exactement une fois à chaque fin de boucle. La boucle est ensuite répétée si la condition est vraie.
Voici un exemple de boucle for traditionnelle de style 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();
Ces boucles sont aussi parfois appelées boucles for numériques par opposition aux boucles foreach (voir ci-dessous).
Boucles for basées sur un itérateur
Ce type de boucle for est une généralisation du type de plage numérique de boucle for, car il permet l'énumération d'ensembles d'éléments autres que des séquences de nombres. Il est généralement caractérisé par l'utilisation d'un itérateur implicite ou explicite , dans lequel la variable de boucle prend chacune des valeurs d'une séquence ou d'une autre collecte de données. Un exemple représentatif en Python est :
for item in some_iterable_object:
do_something()
do_something_else()
Où some_iterable_objectest soit une collection de données qui prend en charge l'itération implicite (comme une liste de noms d'employés), soit peut en fait être un itérateur lui-même. Certains langages ont cela en plus d'une autre syntaxe de boucle for ; notamment, PHP a ce type de boucle sous le nom for each, ainsi qu'une boucle for à trois expressions (voir ci-dessous) sous le nom for.
Boucles for vectorisées
Certains langages offrent une boucle for qui agit comme s'il traitait toutes les itérations en parallèle , comme le for allmot - clé dans FORTRAN 95 qui a l'interprétation que toutes les expressions du côté droit sont évaluées avant toute affectation, contrairement à l'itération explicite former. Par exemple, dans l' forinstruction du fragment de pseudocode suivant, lors du calcul de la nouvelle valeur pour A(i), à l'exception de la première (avec i = 2) la référence à A(i - 1)obtiendra la nouvelle valeur qui y avait été placée à l'étape précédente. Dans la for allversion, cependant, chaque calcul se réfère uniquement à l'original, non modifié 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 différence peut être importante.
Certains langages (tels que FORTRAN 95, PL/I) proposent également des instructions d'affectation de tableau, qui permettent d'omettre de nombreuses boucles for. Ainsi, un pseudocode tel que A := 0;définirait tous les éléments du tableau A à zéro, quelle que soit sa taille ou sa dimensionnalité. L'exemple de boucle pourrait être rendu comme
A(2 : N - 1) := [A(1 : N - 2) + A(2 : N - 1) + A(3 : N)] / 3;
Mais que cela soit rendu dans le style de la boucle for ou de la boucle for all ou autre peut ne pas être clairement décrit dans le manuel du compilateur.
Boucles for composées
Introduit avec ALGOL 68 et suivi de PL/I , cela permet de combiner l'itération d'une boucle avec un test, comme dans
for i := 1 : N while A(i) > 0 do etc.
C'est-à-dire qu'une valeur est affectée à la variable de boucle i et ce n'est que si l' expression while est vraie que le corps de la boucle sera exécuté. Si le résultat était faux, l'exécution de la boucle for s'arrête net. Étant donné que la valeur de la variable de boucle est définie après la fin de la boucle, l'instruction ci-dessus trouvera le premier élément non positif dans le tableau A (et si ce n'est pas le cas, sa valeur sera N + 1 ), ou, avec des variations appropriées , le premier caractère non vide d'une chaîne, et ainsi de suite.
Compteurs de boucle
En programmation informatique, un compteur de boucle est la variable qui contrôle les itérations d'une boucle (une construction de langage de programmation informatique ). Il est ainsi nommé car la plupart des utilisations de cette construction font que la variable prend une plage de valeurs entières dans certaines séquences ordonnées (par exemple, commençant à 0 et se terminant à 10 par incréments de 1)
Les compteurs de boucle changent à chaque itération d'une boucle, fournissant une valeur unique pour chaque itération individuelle. Le compteur de boucle est utilisé pour décider quand la boucle doit se terminer et pour que le déroulement du programme continue jusqu'à l' instruction suivante après la boucle.
Une convention de dénomination d'identifiant courante consiste pour le compteur de boucle à utiliser les noms de variables i , j et k (et ainsi de suite si nécessaire), où i serait la boucle la plus externe, j la boucle interne suivante, etc. L'ordre inverse est également utilisé par certains programmeurs. Il est généralement admis que ce style provient de la première programmation de FORTRAN , où ces noms de variables commençant par ces lettres étaient implicitement déclarés comme ayant un type entier, et étaient donc des choix évidents pour les compteurs de boucles qui n'étaient que temporairement requis. La pratique remonte plus loin à la notation mathématique où les indices pour les sommes et les multiplications sont souvent i , j , etc. Une variante de convention est l'utilisation de lettres dupliquées pour l'index, ii , jj et kk , car cela permet une recherche et une recherche plus faciles. remplacer que d'utiliser une seule lettre.
Exemple
Un exemple de code C impliquant des boucles for imbriquées, où les variables du compteur de boucle sont i et j :
for (i = 0; i < 100; i++) {
for (j = i; j < 10; j++) {
some_function(i, j);
}
}
Il a été montré qu'une boucle for imbriquée, comme dans l'exemple ci-dessus, effectue plus de calculs par unité de temps qu'une boucle sans elle. Cette optimisation indépendante de la machine signifie que la boucle for imbriquée se terminera plus rapidement, étant donné le même nombre de calculs à effectuer. C'est un avantage de la boucle imbriquée for par rapport à la boucle while imbriquée, qui se comporte différemment.
Les boucles for en C peuvent également être utilisées pour imprimer le verso d'un mot. Comme:
for (i = 0; i < 6; i++) {
scanf("%c", &a[i]);
}
for (i = 4; i >= 0; i--) {
printf("%c", a[i]);
}
Ici, si l'entrée est apple, la sortie sera elppa.
Sémantique et constructions supplémentaires
Utiliser comme boucles infinies
Cette boucle for de style C est généralement la source d'une boucle infinie puisque les étapes fondamentales de l'itération sont entièrement sous le contrôle du programmeur. En fait, lorsque des boucles infinies sont prévues, ce type de boucle for peut être utilisé (avec des expressions vides), telles que :
for (;;)
//loop body
Ce style est utilisé à la place des while (1)boucles infinies pour éviter un avertissement de conversion de type dans certains compilateurs C/C++. Certains programmeurs préfèrent la for (;;)forme la plus succincte à la forme sémantiquement équivalente mais plus verbeuse while (true).
Sortie anticipée et continuation
Certains langages peuvent également fournir d'autres déclarations à l'appui, qui, lorsqu'elles sont présentes, peuvent modifier le déroulement de l'itération de la boucle for. Parmi celles-ci, les instructions break and continue trouvées en C et ses dérivés sont courantes . L'instruction break provoque l'arrêt immédiat de la boucle la plus interne lors de son exécution. L'instruction continue passera immédiatement à l'itération suivante sans progresser davantage dans le corps de la boucle pour l'itération en cours. Une instruction for se termine également lorsqu'une instruction break, goto ou return dans le corps de l'instruction est exécutée. [Puits] D'autres langages peuvent avoir des déclarations similaires ou fournir des moyens de modifier la progression de la boucle for ; par exemple 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".
Certains langages offrent d'autres fonctionnalités telles que le nommage des différentes instructions de boucle afin qu'avec plusieurs boucles imbriquées, il n'y ait aucun doute quant à la boucle impliquée. Fortran 95, par exemple :
X1:DO I = 1,N
statements
X2:DO J = 1,M
statements
IF (trouble) CYCLE X1
statements
END DO X2
statements
END DO X1
Ainsi, lorsqu'un "problème" est détecté dans la boucle interne, le CYCLE X1 (pas X2) signifie que le saut sera à l'itération suivante pour I, pas J. Le compilateur vérifiera également que chaque END DO a l'étiquette appropriée pour sa position : ce n'est pas seulement une aide à la documentation. Le programmeur doit toujours coder le problème correctement, mais certaines bévues possibles seront bloquées.
Portée et sémantique des variables de boucle
Différents langages spécifient des règles différentes pour la valeur que la variable de boucle conservera à la fin de sa boucle, et certains soutiennent même qu'elle "devient indéfinie". Cela permet à un compilateur de générer du code qui laisse n'importe quelle valeur dans la variable de boucle, ou peut-être même la laisse inchangée car la valeur de la boucle a été conservée dans un registre et n'a jamais été stockée en mémoire. Le comportement réel peut même varier en fonction des paramètres d'optimisation du compilateur, comme avec le compilateur Honywell Fortran66.
Dans certains langages (pas C ou C++ ) la variable de boucle est immuable dans la portée du corps de la boucle, toute tentative de modification de sa valeur étant considérée comme une erreur sémantique. De telles modifications sont parfois la conséquence d'une erreur du programmeur, qui peut être très difficile à identifier une fois effectuée. Cependant, seuls les changements manifestes sont susceptibles d'être détectés par le compilateur. Les situations où l'adresse de la variable de boucle est passée en argument à une sous - routine rendent la vérification très difficile, car le comportement de la routine est en général inconnu du compilateur. Quelques exemples dans le style 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?
Une approche courante consiste à calculer le nombre d'itérations au début d'une boucle (avec une attention particulière au débordement comme dans l' for i := 0 : 65535 do ... ;arithmétique des entiers à seize bits) et à chaque itération de décrémenter ce nombre tout en ajustant la valeur de I : résultats du double comptage. Cependant, les ajustements de la valeur de I dans la boucle ne changeront pas le nombre d'itérations exécutées.
Encore une autre possibilité est que le code généré puisse utiliser une variable auxiliaire comme variable de boucle, éventuellement conservée dans un registre machine, dont la valeur peut ou non être copiée dans I à chaque itération. Encore une fois, les modifications de I n'affecteraient pas le contrôle de la boucle, mais maintenant une disjonction est possible : à l'intérieur de la boucle, les références à la valeur de I pourraient être à la valeur actuelle (éventuellement modifiée) de I ou à la variable auxiliaire (maintenue à l'abri d'une modification inappropriée) et des résultats déroutants sont garantis. Par exemple, dans la boucle, une référence à l'élément I d'un tableau emploierait probablement la variable auxiliaire (surtout si elle était contenue dans un registre machine), mais si I est un paramètre d'une routine (par exemple, une instruction print à révéler sa valeur), ce serait probablement une référence à la variable appropriée I à la place. Il est préférable d'éviter de telles possibilités.
Ajustement des bornes
Tout comme la variable d'index peut être modifiée dans une boucle for, il en va de même pour ses limites et sa direction. Mais à effet incertain. Un compilateur peut empêcher de telles tentatives, elles peuvent n'avoir aucun effet, ou elles peuvent même fonctionner correctement - bien que beaucoup déclarent que ce serait une erreur. Considérez une déclaration telle que
for i := first : last : step do A(i) := A(i) / A(last);
Si l'approche pour compiler une telle boucle devait être l'évaluation de first , last et step et le calcul d'un nombre d'itérations via quelque chose comme (last - first)/stepune seule fois au début, alors si ces éléments étaient de simples variables et que leurs valeurs étaient en quelque sorte ajustées au cours de la itérations, cela n'aurait aucun effet sur le nombre d'itérations même si l'élément sélectionné pour la division par A(last)changeait.
Liste des plages de valeurs
PL/I et Algol 68, permettent des boucles dans lesquelles la variable de boucle est itérée sur une liste de plages de valeurs au lieu d'une seule plage. L'exemple PL/I suivant exécutera la boucle avec six valeurs de i : 1, 7, 12, 13, 14, 15 :
do i = 1, 7, 12 to 15;
/*statements*/
end;
Équivalence avec les boucles while
Une boucle for est généralement équivalente à une boucle while :
factorial := 1
for counter from 2 to 5
factorial := factorial * counter
counter := counter - 1
print counter + "! equals " + factorial
est équivalent à:
factorial := 1
counter := 1
while counter < 5
counter := counter + 1
factorial := factorial * counter
print counter + "! equals " + factorial
comme le montre la sortie des variables.
Chronologie de la syntaxe de la boucle for dans divers langages de programmation
Étant donné une action qui doit être répétée, par exemple, cinq fois, les boucles for de différentes langues seront écrites différemment. La syntaxe d'une boucle for à trois expressions est presque identique dans tous les langages qui l'ont, après prise en compte des différents styles de terminaison de bloc, etc.
1957 : FORTRAN
L'équivalent Fortran de la boucle for est la boucle DO , en utilisant le mot-clé do au lieu de for. La syntaxe de la boucle DO de Fortran est :
DO label counter = first, last, step
statements
label statement
Les deux exemples suivants se comportent de manière équivalente à la boucle for à trois arguments dans d'autres langages, initialisant la variable compteur à 1, incrémentant de 1 à chaque itération de la boucle et s'arrêtant à cinq (inclus).
DO 9, COUNTER = 1, 5, 1
WRITE (6,8) COUNTER
8 FORMAT( I2 )
9 CONTINUE
En Fortran 77 (ou ultérieur), cela peut aussi s'écrire :
do counter = 1, 5
write(*, '(i2)') counter
end do
La partie étape peut être omise si l'étape est une. Exemple:
* 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
Les espaces ne sont pas pertinents dans les instructions Fortran à forme fixe, donc SUM SQ est identique à SUMSQ . Dans le style fortran moderne de forme libre, les blancs sont importants.
En Fortran 90, le GO TO peut être évité en utilisant une instruction 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 a introduit la fordéclaration, en utilisant le formulaire comme Superplan :
FOR Identifier = Base (Difference) Limit
Par exemple pour imprimer de 0 à 10 incrémenté de 1 :
FOR x = 0 (1) 10 BEGIN PRINT (FL) = x END
1960 : COBOL
Le COBOL a été formalisé fin 1959 et a connu de nombreuses élaborations. Il utilise le verbe PERFORM qui a de nombreuses options. À l'origine, toutes les boucles devaient être hors ligne, le code itéré occupant un paragraphe séparé. En ignorant la nécessité de déclarer et d'initialiser des variables, l'équivalent COBOL d'une boucle for serait.
PERFORM SQ-ROUTINE VARYING I FROM 1 BY 1 UNTIL I > 1000
SQ-ROUTINE
ADD I**2 TO SUM-SQ.
Dans les années 1980, l'ajout de boucles en ligne et d'instructions "structurées" telles que END-PERFORM a donné lieu à une boucle for avec une structure plus familière.
PERFORM VARYING I FROM 1 BY 1 UNTIL I > 1000
ADD I**2 TO SUM-SQ.
END-PERFORM
Si le verbe PERFORM a la clause optionnelle TEST AFTER, la boucle résultante est légèrement différente : le corps de la boucle est exécuté au moins une fois, avant tout test.
1964 : BASE
Les boucles en BASIC sont parfois appelées boucles 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
Notez que le marqueur de fin de boucle spécifie le nom de la variable d'index, qui doit correspondre au nom de la variable d'index au début de la boucle for. Certains langages (PL/I, FORTRAN 95 et versions ultérieures) autorisent une étiquette d'instruction au début d'une boucle for qui peut être comparée par le compilateur au même texte sur l'instruction de fin de boucle correspondante. Fortran permet également aux instructions EXITet CYCLEde nommer ce texte ; dans un nid de boucles, cela indique clairement quelle boucle est destinée. Cependant, dans ces langues, les étiquettes doivent être uniques, de sorte que les boucles successives impliquant la même variable d'index ne peuvent pas utiliser le même texte et une étiquette ne peut pas être identique au nom d'une variable, telle que la variable d'index de la boucle.
1964 : PL/I
do counter = 1 to 5 by 1; /* "by 1" is the default if not specified */
/*statements*/;
end;
L' instruction LEAVE peut être utilisée pour quitter la boucle. Les boucles peuvent être étiquetées et laisser peut laisser une boucle étiquetée spécifique dans un groupe de boucles imbriquées. Certains dialectes PL/I incluent l' instruction ITERATE pour terminer l'itération de la boucle en cours et commencer la suivante.
1968 : Algol 68
ALGOL 68 a ce qui était considéré comme la boucle universelle, la syntaxe complète est :
FOR i FROM 1 BY 2 TO 3 WHILE i≠4 DO ~ OD
En outre, la plage d'itérations unique pourrait être remplacée par une liste de ces plages. Il y a plusieurs aspects inhabituels de la construction
- seule la
do ~ odportion était obligatoire, auquel cas la boucle sera itérée indéfiniment. - ainsi la clause
to 100 do ~ od, itérera exactement 100 fois. - l'
whileélément syntaxique a permis à un programmeur de sortir d'uneforboucle tôt, comme dans :
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
Les extensions ultérieures de l'Algol68 standard ont permis de remplacer l' toélément syntaxique uptoet downtod'obtenir une petite optimisation. Les mêmes compilateurs ont également incorporé :
until- pour la fin de boucle tardive.
foreach- pour travailler sur des tableaux en parallèle .
1970 : Pascal
for Counter := 1 to 5 do
(*statement*);
Décrémenter (compter à rebours) utilise un downtomot-clé au lieu de to, comme dans :
for Counter := 5 downto 1 do
(*statement*);
La boucle for de la plage numérique varie un peu plus.
1972 : C/C++
for (initialization; condition; increment/decrement)
statement
L' instruction est souvent une instruction de bloc ; un exemple de ceci serait :
//Using for-loops to add numbers 1 - 5
int sum = 0;
for (int i = 1; i < 6; ++i) {
sum += i;
}
La publication ISO/IEC 9899:1999 (communément appelée C99 ) autorise également les déclarations initiales en forboucles. Les trois sections de la boucle for sont facultatives.
1972 : Petite conversation
1 to: 5 do: [ :counter | "statements" ]
Contrairement à d'autres langages, en Smalltalk, une boucle for n'est pas une construction de langage mais définie dans la classe Number comme une méthode avec deux paramètres, la valeur de fin et une fermeture , en utilisant self comme valeur de départ.
1980 : Ada
for Counter in 1 .. 5 loop
-- statements
end loop;
L' instruction exit peut être utilisée pour quitter la boucle. Les boucles peuvent être étiquetées et exit peut laisser une boucle spécifiquement étiquetée dans un groupe de boucles imbriquées :
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 : Érable
Maple a deux formes de boucle for, l'une pour l'itération d'une plage de valeurs et l'autre pour l'itération sur le contenu d'un conteneur. La forme de la plage de valeurs est la suivante :
for i from f by b to t while w do
# loop body
od;
Toutes les pièces sauf doet odsont facultatives. La partie, si elle est présente, doit venir en premier. Les parties restantes ( , , , ) peuvent apparaître dans n'importe quel ordre.
for ifrom fby bto twhile w
L'itération sur un conteneur se fait à l'aide de cette forme de boucle :
for e in c while w do
# loop body
od;
La clause spécifie le conteneur, qui peut être une liste, un ensemble, une somme, un produit, une fonction non évaluée, un tableau ou un objet implémentant un itérateur.
in c
Une boucle for peut se terminer par od, end, ou end do.
1982 : Maxima CAS
Dans Maxima CAS on peut aussi utiliser des valeurs non entières :
for x:0.5 step 0.1 thru 0.9 do
/* "Do something with x" */
1982 : PostScript
La boucle for, écrite comme [initial] [increment] [limit] { ... } forinitialise une variable interne, exécute le corps tant que la variable interne n'est pas supérieure à la limite (ou pas inférieure, si l'incrément est négatif) et, à la fin de chaque itération, incrémente la variable interne. Avant chaque itération, la valeur de la variable interne est poussée sur la pile.
1 1 6 {STATEMENTS} for
Il y a aussi une simple boucle de répétition. La boucle de répétition, écrite sous la forme X { ... } repeat, répète le corps exactement X fois.
5 { STATEMENTS } repeat
1983 : Ada 83 et plus
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
Après la boucle, nserait 5 dans cet exemple.
Comme ic'est le cas pour l' unité imaginaire , son utilisation en tant que variable de boucle est déconseillée.
1987 : Perle
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;
}
(Notez que " il y a plus d'une façon de le faire " est une devise de programmation Perl.)
1988 : Mathématique
La construction correspondant à la boucle for de la plupart des autres langages est appelée Do dans Mathematica
Do[f[x], {x, 0, 1, 0.1}]
Mathematica a également une construction For qui imite la boucle for des langages de type 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
Notez qu'une boucle vide (c'est-à-dire une boucle sans commandes entre doet done) est une erreur de syntaxe. Si les boucles ci-dessus ne contenaient que des commentaires, l'exécution entraînerait le message "erreur de syntaxe proche du jeton inattendu 'fait'".
1990 : Haskell
L'impératif intégré forM_ mappe une expression monadique dans une liste, comme
forM_ [1..5] $ \indx -> do statements
ou obtenir le résultat de chaque itération sous forme de liste dans
statements_result_list <- forM [1..5] $ \indx -> do statements
Mais, si vous voulez économiser l'espace de la liste [1..5], une construction forLoop_ monadique plus authentique peut être définie comme
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
et utilisé comme :
forLoopM_ (0::Int) (< len) (+1) $ \indx -> do -- whatever with the index
1991 : Oberon-2, Oberon-07 ou Composant Pascal
FOR Counter := 1 TO 5 DO
(* statement sequence *)
END
Notez que dans le langage d'origine Oberon, la boucle for a été omise au profit de la construction de boucle Oberon plus générale. La boucle for a été réintroduite dans Oberon-2.
1991 : Python
Python ne contient pas la boucle for classique, une foreachboucle est plutôt utilisée pour itérer sur la sortie de la range()fonction intégrée qui renvoie une liste itérable d'entiers.
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)
L'utilisation range(6)exécuterait la boucle de 0 à 5.
1993 : AppleScript
repeat with i from 1 to 5
-- statements
log i
end repeat
Vous pouvez également parcourir une liste d'éléments, similaire à ce que vous pouvez faire avec des tableaux dans d'autres langues :
set x to {1, "waffles", "bacon", 5.1, false}
repeat with i in x
log i
end repeat
Vous pouvez également utiliser exit repeatpour quitter une boucle à tout moment. Contrairement à d'autres langages, AppleScript n'a actuellement aucune commande pour continuer à l'itération suivante d'une boucle.
1993 : Lua
for i = start, stop, interval do
-- statements
end
Alors, ce code
for i = 1, 5, 2 do
print(i)
end
imprimera :
1 3 5
Les boucles For peuvent également parcourir une table en utilisant
ipairs()
itérer numériquement à travers des tableaux et
pairs()
itérer au hasard dans les dictionnaires.
Boucle for générique utilisant des fermetures :
for name, phone, address in contacts() do
-- contacts() must be an iterator function
end
1995 : CFML
Syntaxe de script
Boucle d'index simple :
for (i = 1; i <= 5; i++) {
// statements
}
Utilisation d'un tableau :
for (i in [1,2,3,4,5]) {
// statements
}
Utilisation d'une liste de valeurs de chaîne :
loop index="i" list="1;2,3;4,5" delimiters=",;" {
// statements
}
L' listexemple ci-dessus n'est disponible que dans le dialecte de CFML utilisé par Lucee et Railo .
Syntaxe des balises
Boucle d'index simple :
<cfloop index="i" from="1" to="5">
<!--- statements --->
</cfloop>
Utilisation d'un tableau :
<cfloop index="i" array="#[1,2,3,4,5]#">
<!--- statements --->
</cfloop>
Utilisation d'une "liste" de valeurs de chaîne :
<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
}
Pour la boucle for étendue, voir Boucle Foreach § Java .
1995 : Javascript
JavaScript prend en charge les boucles "à trois expressions" de style C. Les instructions breaket continuesont prises en charge à l'intérieur des boucles.
for (var i = 0; i < 5; i++) {
// ...
}
Alternativement, il est possible d'itérer sur toutes les clés d'un tableau.
for (var key in array) { // also works for assoc. arrays
// use array[key]
...
}
1995 : PHP
Cela imprime un triangle de *
for ($i = 0; $i <= 5; $i++) {
for ($j = 0; $j <= $i; $j++) {
echo "*";
}
echo "<br />\n";
}
1995 : Rubis
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 a plusieurs syntaxes possibles, y compris les exemples ci-dessus.
1996 : OCaml
Voir la syntaxe des expressions.
(* 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 : Petit basique
For i = 1 To 10
' Statements
EndFor
2008 : Nim
Nim a une foreachboucle de type - et diverses opérations pour créer des itérateurs.
for i in 5 .. 10:
# statements
2009 : Allez
for i := 0; i <= 10; i++ {
// statements
}
2010 : Rouille
for i in 0..10 {
// statements
}
2012 : Julie
for j = 1:10
# statements
end