Comprendre et utiliser les boucles dans la programmation Delphi

La boucle est un élément commun à tous les langages de programmation. Delphi dispose de trois structures de contrôle qui exécutent des blocs de code à plusieurs reprises: pour, répéter… jusqu'à et pendant… faire.

La boucle FOR

Supposons que nous devons répéter une opération un nombre fixe de fois.

// affiche les boîtes de message 1,2,3,4,5
var j: entier;
commencer
pour j: = 1 à 5 faire
commencer
ShowMessage ('Box:' + IntToStr (j));
fin;
fin;

La valeur d'une variable de contrôle (j), qui n'est en fait qu'un compteur, détermine combien de fois une instruction for s'exécute. Le mot clé pour configurer un compteur. Dans l'exemple précédent, la valeur de départ du compteur est définie sur 1. La valeur de fin est définie sur 5.
Lorsque l'instruction for commence à s'exécuter, la variable de compteur prend la valeur de départ. Delphi than vérifie si la valeur du compteur est inférieure à la valeur de fin. Si la valeur est supérieure, rien n'est fait (l'exécution du programme passe à la ligne de code suivant immédiatement le bloc de code de boucle for). Si la valeur de départ est inférieure à la valeur de fin, le corps de la boucle est exécuté (ici: la boîte de message s'affiche). Enfin, Delphi ajoute 1 au compteur et recommence le processus.

Parfois, il faut compter à rebours. le vers le bas Le mot clé spécifie que la valeur d'un compteur doit être décrémentée de un à chaque exécution de la boucle (il n'est pas possible de spécifier un incrément / décrément autre que un). Un exemple de boucle for qui compte en arrière.

var j: entier;
commencer
pour j: = 5 vers le bas 1 faire
commencer
ShowMessage ('T moins' + IntToStr (j) + 'secondes');
fin;
ShowMessage ('Pour séquence exécutée!');
fin;

Remarque: il est important de ne jamais modifier la valeur de la variable de contrôle au milieu de la boucle. Cela entraînerait des erreurs.

Boucles FOR imbriquées

L'écriture d'une boucle for dans une autre boucle for (boucles d'imbrication) est très utile lorsque vous souhaitez remplir / afficher des données dans un tableau ou une grille.

var k, j: entier;
commencer
// cette double boucle est exécutée 4x4 = 16 fois
pour k: = 1 à 4 faire
pour j: = 4 vers le bas 1 faire
ShowMessage ('Boîte:' + IntToStr (k) + ',' + IntToStr (j));
fin;

La règle d'imbrication des boucles for-next est simple: la boucle interne (compteur j) doit être terminée avant de rencontrer l'instruction suivante pour la boucle externe (compteur k). On peut avoir des boucles imbriquées triplement ou quadruplement, voire plus.

Remarque: En règle générale, les mots clés de début et de fin ne sont pas strictement requis, comme vous pouvez le voir. Si begin et end ne sont pas utilisés, l'instruction qui suit immédiatement l'instruction for est considérée comme le corps de la boucle.

La boucle FOR-IN

Si vous disposez de Delphi 2005 ou d'une version plus récente, vous pouvez utiliser la "nouvelle" itération de style pour l'élément dans la collection sur les conteneurs. L'exemple suivant illustre l'itération sur les expressions de chaîne: pour chaque caractère dans la chaîne, vérifiez si le caractère est 'a' ou 'e' ou 'i'.

const
s = 'À propos de la programmation Delphi';
var
c: char;
commencer
pour c dans s faire
commencer
si c dans ['a', 'e', ​​'i'] ensuite
commencer
// faire quelque chose
fin;
fin;
fin;

Les boucles WHILE et REPEAT

Parfois, nous ne savons pas exactement combien de fois une boucle doit se répéter. Et si nous voulons répéter une opération jusqu'à ce que nous atteignions un objectif spécifique?

La différence la plus importante entre la boucle while-do et la boucle repeat-until est que le code de l'instruction repeat est toujours exécuté au moins une fois.

Le modèle général lorsque nous écrivons un type de boucle de répétition (et while) dans Delphi est le suivant:

répéter
commencer
déclarations;
fin;
jusqu'à condition = true

tandis que condition = true faire
commencer
déclarations;
fin;

Voici le code pour afficher 5 boîtes de message successives en utilisant la répétition jusqu'à:

var
j: entier;
commencer
j: = 0;
répéter
commencer
j: = j + 1;
ShowMessage ('Box:' + IntToStr (j));
fin;
jusqu'à j> 5;
fin;

Comme vous pouvez le voir, l'instruction repeat évalue une condition à la fin de la boucle (donc la boucle de répétition est exécutée à coup sûr au moins une fois).

L'instruction while, en revanche, évalue une condition au début de la boucle. Étant donné que le test est effectué en haut, nous devons généralement nous assurer que la condition a du sens avant le traitement de la boucle, si ce n'est pas le cas, le compilateur peut décider de supprimer la boucle du code.

var j: entier;
commencer
j: = 0;
tandis que j < 5 faire
commencer
j: = j + 1;
ShowMessage ('Box:' + IntToStr (j));
fin;
fin;

Break and Continue

Les procédures Break et Continue peuvent être utilisées pour contrôler le flux d'instructions répétitives: La procédure Break fait que le flux de contrôle quitte une instruction for, while ou repeat et continue à l'instruction suivante qui suit l'instruction loop. Continuer permet au flux de contrôle de passer à la prochaine itération de l'opération répétée.