For

Les expressions for, parfois appelées boucles for, sont identiques aux expressions loop, hormis le fait que les expressions for itèrent sur un nombre lié d'éléments. Autrement dit, le nombre d'itérations est connu avant l'exécution de la boucle for, et les décisions concernant le moment de quitter la boucle sont automatisées pour vous.

Le déclencheur d'impulsions est un exemple de boucle for avec des itérations définies lorsque vous définissez le paramètre Bouclage du déclencheur d'impulsions sur un nombre. L'impulsion du déclencheur se répète autant de fois que spécifié par le paramètre Bouclage de l'appareil.

Dans cet exemple, deux déclencheurs se trouvent sur le chemin du déclencheur d'impulsion. Lorsque l'impulsion atteint un déclencheur, ce dernier envoie un signal pour afficher un texte sur l'un des appareils du panneau d'affichage et se répète trois fois.

Sous forme de code, cet exemple pourrait ressembler à ceci :

for (X := 0..2):
    TriggerDevice1.Transmit()
    TriggerDevice2.Transmit()

L'expression for contient deux parties :

• Spécification d'itération : les expressions entre parenthèses et la première expression doivent être un générateur. Dans cet exemple, il s'agit de (X := 0..2).

• Corps : les expressions après les parenthèses. Dans cet exemple, il s'agit des deux lignes avec Transmit().

Générateur

Un générateur produit une séquence de valeurs (une à la fois) et donne un nom à la valeur. Dans cet exemple, le générateur étant X := 0..2, à chaque itération de la boucle le générateur produit la valeur suivante et lui donne le nom X. Lorsque le générateur atteint la fin de la séquence, la boucle for prend fin. Ce flux décisionnel consistant à vérifier si la variable de la boucle a une valeur valide est intégré à l'expression for. Les générateurs ne prennent en charge que les plages, les matrices et les mappages.

Itérer sur une plage

Le type de plage représente une série de nombres entiers ; par exemple, 0..3 et Min..Max.

Le début de la plage est la première valeur de l'expression, par exemple 0, et la fin de la plage est la valeur suivant .. dans l'expression, par exemple 3. La plage contient tous les nombres entiers compris entre les valeurs de début et de fin, et les inclut. Par exemple, l'expression de plage 0..3 contient les nombres 0, 1, 2 et 3. Les expressions de plage ne prennent en charge que les valeurs int et ne peuvent être utilisées que dans les expressions for, sync, race et rush.

for (Number := 0 .. 3):
    Log("{Number}")

Le résultat ajoute quatre lignes au journal contenant les nombres 0, 1, 2 et 3.

Une expression for peut renvoyer les résultats de chaque itération dans une matrice. Dans l'exemple suivant, Numbers est une matrice immuable avec les valeurs int de -1 à -10.

Numbers := for (Number := 1..10):
    -Number

Itérer sur une matrice ou un mappage

Les itérations sur les matrices et les mappages peuvent être juste les valeurs, ou la paire clé-valeur pour les mappages et la paire index-valeur pour les matrices.

Dans ce cas, seules les valeurs de la matrice sont utilisées, et Values est une matrice immuable avec les valeurs int 2, 3 et 5.

Values := for (X : array{1, 2, 4}):
    X+1

Il en est de même avec un mappage ; Values est dans ce cas une matrice immuable avec les valeurs int 3,7.

Values :=  for  (X := map{ 1=>3,  0=>7 }):
    X

Le motif X->Y peut être utilisé pour déconstruire une paire index-valeur ou clé-valeur. L'index (ou clé) est lié à la partie gauche (X), et la valeur est liée à la partie droite (Y). Exemple de paires index-valeur d'une matrice : Values est une matrice immuable avec les valeurs int 1, 3 et 6.

Values := for ( X -> Y : array{1, 2, 4}) :
    X + Y

Exemple de paire index-valeur d'un mappage : Values est une matrice immuable avec les valeurs int 4 et 7.

Values  :=  for ( X->Y := map{ 1=>3,  0=>7 }):
    X + Y

Filtre

Vous pouvez ajouter des expressions faillibles à l'expression for pour filtrer les valeurs du générateur. Si le filtre échoue, cette itération ne donne aucun résultat et for passe à la prochaine valeur produite par le générateur.

Par exemple, le filtre Num <> 0 est ajouté à l'expression for pour exclure 0 des résultats renvoyés.

NoZero := for (Number := -5..5, Number <> 0):
    Number

Syntaxiquement, cela équivaut à :

expression0
for (Item : Collection, test-arg-block):
    expression1
expression2

Définition

Vous pouvez également ajouter des expressions nommées à la spécification d'itération, et le nom peut être utilisé à la fois dans la spécification d'itération et dans le corps.

Values := for ( X := 1..5; Y:=SomeFunction(X); Y < 10):
    Y

Résultat : une matrice avec au maximum 5 éléments où toutes les valeurs sont inférieures à 10

## For imbriqué

Vous pouvez imbriquer une boucle for dans une autre boucle for. Il y a deux façons de procéder :

• Expression For unique : spécifiée par plusieurs générateurs. Le résultat est une matrice unidimensionnelle.

• Expressions For multiples : blocs for distincts. Le résultat est une matrice multidimensionnelle.

Les sections ci-dessous les décrivent plus en détail.

Expression For unique

Vous pouvez disposer de plusieurs boucles dans une seule expression for en ajoutant plusieurs générateurs. Le résultat d'une seule expression for avec plusieurs générateurs est une matrice unidimensionnelle.

Dans cet exemple, Values est une matrice immuable avec les valeurs int 13, 14, 23 et 24.

Values := for(X:=1..2, Y:=3..4):
        X * 10 + Y

Sémantiquement, c'est la même chose que :

expression0
for (Item : Collection, Item2 : Collection2):
    expression1
expression2

Expressions For multiples

Vous pouvez également imbriquer une expression for dans le corps d'une autre boucle for. Dans la mesure où une expression for renvoie une matrice unidimensionnelle, l'imbrication d'une expression for renvoie une matrice bidimensionnelle.

Dans ce cas, Values est une matrice immuable avec deux matrices int immuables. La première matrice contient les valeurs 13 et 14, et la deuxième matrice contient 23 et 24. Vous pouvez écrire cela comme suit : array{ array{13, 14}, array{23, 24} }.

Values := for ( X := 1..2 ):
    for (Y := 3..4):
        X * 10 + Y

Échec

En cas d'échec dans la spécification de l'itération, toutes les modifications dues à cette itération sont annulées.

for(X := 1..5; S := IncrementSomeVariable(); X < 3):
    X

Le résultat de cette expression for est array{1,2}, et seulement deux appels à IncrementSomeVariable après l'évaluation de la boucle for, car les autres appels ont été annulés lorsque le filtre X < 3 a échoué.