Pour chaque...Fin de chaque

La syntaxe de la structure répétitive (ou boucle) Pour chaque...Fin de chaque est la suivante :

La structure Pour chaque...Fin de chaque exécute le cycle d'instructions définies pour chaque Elément_courant de Expression. Le type de Elément_courant dépend du type de Expression. La boucle Pour chaque...Fin de chaque peut itérer parmi trois types d'Expression :

• collections : boucle sur chaque élément de la collection,
• entity selections : boucle sur chaque entity,
• objets : boucle sur chaque propriété d'objet.

Le tableau suivant compare les trois types de Pour chaque...Fin de chaque :

• Le nombre de boucles est évalué au démarrage et ne changera pas en cours de traitement. L'ajout ou la suppression d'éléments pendant la boucle est donc déconseillé car il pourra en résulter une redondance ou un manque d'itérations.
• Par défaut, les instructions incluses sont exécutées pour chaque valeur de Expression. Il est toutefois possible de sortir de la boucle en testant une condition soit au début de chaque itération (Tant que) ou à la fin de chaque itération (Jusque).
• Les paramètres optionnels début et fin peuvent être utilisés avec les collections et les entity selections afin de définir des bornes pour la boucle.

Lorsque Pour chaque...Fin de chaque est utilisée avec une Expression de type Collection, le paramètre Elément_courant est une variable du même type que les éléments de la collection. Par défaut, le nombre de boucles est basé sur le nombre d'éléments de la collection.

La collection doit contenir uniquement des éléments du même type. Dans le cas contraire, une erreur sera retournée dès que la première valeur de type différent sera assignée à la variable Elément_courant.

A chaque itération de la boucle, la variable Elément_courant reçoit automatiquement l'élément correspondant de la collection. Vous devez tenir compte des points suivants :

• Si la variable Elément_courant est de type objet ou collection (i.e. si Expression est une collection d'objets ou une collection de collections), la modification de cette variable modifiera automatiquement l'élément correspondant de la collection (car les objets et les collections sont passés par référence). Si la variable est de type scalaire, sa modification ne sera pas répercutée sur l'élément de la collection.
• La variable Elément_courant doit être du même type que les éléments de la collection. Si un seul élément de la collection n'est pas du même type que la variable, une erreur est générée et la boucle s'arrête.
• Si la collection contient des éléments de valeur Null, une erreur sera générée si le type de la variable Elément_courant ne prend pas en charge la valeur Null (comme par exemple les variables entier long).

Vous souhaitez calculer quelques statistiques sur une collection de nombres :

Lorsque Pour chaque...Fin de chaque est utilisée avec une Expression de type Entity selection, le paramètre Elément_courant contient l'entity en cours de traitement.

Le nombre de boucles est basé sur le nombre d'entities présentes dans l'entity selection. A chaque itération de la boucle, le paramètre Elément_courant reçoit automatiquement l'entity qui est en cours de traitement.

Note : Si l'entity selection contient la référence d'une entity qui a été supprimée entre-temps par un autre process, elle est automatiquement ignorée durant la boucle.

N'oubliez pas que toute modification effectuée sur l'entity en cours de traitement doit être explicitement sauvegardée (si nécessaire) à l'aide de la méthode entity.save( ).

Vous souhaitez augmenter le salaire de tous les employés britanniques dans une entity selection : 

Lorsque Pour chaque...Fin de chaque est utilisée avec une Expression de type Objet, le paramètre Elément_courant est une variable texte qui reçoit automatiquement le nom de la propriété en cours de traitement. 

Les propriétés de l'objet sont itérées en fonction de leur ordre de création. Pendant la boucle, il est possible d'ajouter ou de supprimer des propriétés dans l'objet, sans pour autant modifier le nombre de boucles qui reste basé sur le nombre de propriétés initial de l'objet.

Vous souhaitez passer en majuscules les propriétés contenant des noms dans l'objet suivant :

{
    "firstname": "gregory",
    "lastname": "badikora",
    "age": 20
}

Vous pouvez écrire :

{
    "firstname": "GREGORY",
    "lastname": "BADIKORA",
    "age": 20
}

Vous pouvez définir des bornes pour l'itération à l'aide des paramètres optionnels début et fin.

Note : Les paramètres début et fin sont utilisables uniquement avec les boucles sur des collections et des entity selections (ils sont ignorés avec les boucles sur des propriétés d'objets).

• Dans le paramètre début, passez la position de l'élément de Expression auquel démarrer l'itération (début est inclus).
• Dans le paramètre fin, vous pouvez passer la position de l'élément de Expression auquel stopper l'itération (fin est exclus).

Si fin est omis ou si fin est plus grand que le nombre d'éléments de Expression, les éléments sont itérés depuis début jusqu'au dernier inclus.

Si les paramètres début et fin sont des valeurs positives, ils représentent des positions d'éléments dans Expression.

Si début est une valeur négative, elle est recalculée comme début:=début+Taille expression (elle est considérée comme un décalage à partir de la fin de Expression). Si la valeur calculée est négative, début prend la valeur 0.
Note : Même si début est une valeur négative, l'itération est toujours effectuée dans le même ordre.
Si fin est une valeur négative, elle est recalculée comme fin:=fin+Taille expression

Par exemple :

• une collection contient 10 éléments (numérotés de 0 à 9)
• début=-4 -> début=-4+10=6 -> l'itération démarre au 6e élément (numéro 5)
• fin=-2 -> fin=-2+10=8 -> l'itération stoppe avant le 8e élément (numéro 7), i.e. après le 7e élément.

Vous pouvez contrôler l'exécution de Pour chaque...Fin de chaque en ajoutant une condition Jusque ou Tant que à la boucle. Lorsqu'une instruction Jusque(condition) ou Tant que(condition) est associée à la boucle, l'itération stoppe dès que la condition est évaluée à Vrai.

Vous pouvez passer un mot-clé ou l'autre en fonction de vos besoin :

• La condition Jusque est testée à la fin de chaque itération, donc si Expression n'est ni vide ni Null, la boucle sera exécutée au moins une fois.
• La condition Tant que est testée au début de chaque itération, donc en fonction du résultat de la condition, la boucle peut ne pas être exécutée du tout.

La boucle Pour chaque...Fin de chaque peut être utilisée sur une collection partagée ou un objet partagé.

Si votre code doit modifier un ou plusieurs éléments de la collection ou propriétés de l'objet, vous devez utiliser les mots-clés Utiliser...Fin utiliser. En fonction de vos besoins, vous pouvez appeler les mots-clés Utiliser...Fin utiliser :

• avant d'entrer dans la boucle, si les éléments doivent être modifiés ensemble pour des préserver l'intégrité des données, ou
• à l'intérieur de la boucle lorsque certain(e)s élements/propriétés uniquement doivent être modifié(e)s et qu'aucune gestion d'intégrité spécifique n'est requise.