Cette instruction permet d'incrémenter une variable à partir d'une valeur inférieure jusqu'à une valeur supérieure et d'exécuter une ou des instructions entre chaque incrémentation. Les extrema doivent être de type scalaire. La boucle n'exécute les instructions de son bloc interne que si la valeur inférieure est effectivement inférieure ou égale à celle de la borne supérieure.

Le pas de variation est l'unité et ne peut pas être changé.

Syntaxe :

For variable := borne_inferieure to borne_superieure do {instruction};

Autre syntaxe :

For variable := borne_inferieure to borne_superieure do
  begin
    ...
  end;

Exemple :

Program Exemple5;

Var i : Integer;

Begin
  For i := 10 to 53 do WriteLn ('Valeur de i : ', i);
End.

Cette instruction permet de décrémenter une variable à partir d'une valeur supérieure jusqu'à une valeur inférieure et d'exécuter une ou des instructions entre chaque décrémentation.
S'appliquent ici les mêmes remarques que précédement.

Syntaxe :

For variable := borne_superieure downto borne_inferieur do {instruction};

Autre syntaxe :

For variable := borne_superieure downto borne_inferieure do
  begin
    ...
  end;

Exemple :

Program Exemple6;

Var i : Integer;

Begin
  For i := 100 downto 0 do
    begin
      WriteLn ('Valeur de i : ', i );
    end;
End.

Cette boucle effectue les instructions placées entre deux bornes (repeat et until) et évalue à chaque répétition une condition de type booléenne avant de continuer la boucle pour décider l'arrêt ou la continuité de la répétition.

Il y a donc au moins une fois exécution des instructions.

Syntaxe :

Repeat
  ...
until condition_est_vraie;

Exemple :

Program Exemple7;

Var i : Integer;

Begin
  Repeat
    Inc(i);
    Writeln ('Boucle itérée ', i, ' fois.');
  until i > 20 ;
End.

Ce programme Exemple7 permet de répéter l'incrémentation de la variable i jusqu'à ce que i soit supérieure à 20.

Note :

L'instruction Inc permet d'incrémenter une variable d'une certaine valeur. L'instruction Dec permet au contraire de décrémenter une variable d'une certaine valeur. Si la valeur en question est 1, elle peut être omise.
Ces instructions permettent d'éviter la syntaxe : variable := variable + 1 et variable := variable - 1.

Syntaxe :

Inc(variable,nombre);
Dec(variable);   (* Décrémentation de 1 *)

Ce type de boucle, contrairement à la précédente, évalue une condition avant d'exécuter des instructions.

C'est-à-dire qu'on peut ne pas entrer dans la structure de répétition si les conditions ne sont pas favorables.

Syntaxe :

While condition_est_vraie do {instruction};

Autre syntaxe :

While condition_est_vraie do
  begin
    ...
  end;

Exemple :

Program Exemple8;

Var 
  CodeCorrect : Boolean;
  Essai : String;

Const 
  LeVraiCode = 'password';

Begin
  CodeCorrect := False;
  While not CodeCorrect do
    begin
      Write('Entrez le code secret : ');
      Readln(Essai);
      if Essai = LeVraiCode then CodeCorrect := True;
    end ;
End.

Il est possible de terminer une boucle For, While ou Repeat> en cours grâce à la commande Break lorsque celle-ci est placée au sein de la boucle en question.

Exemple :

Program Arret;

Var i, x : Integer;

Begin
  x := 0 ;
  Repeat
    Inc(i);
    Break;
    x := 50;
  until i > 10;
  WriteLn(i);
  WriteLn(x);
End.

L'exécution des instructions contenues dans la boucle repeat est stoppée à l'instruction Break, et donc x := 50; n'est jamais exécuté. En sortie de boucle, i vaudra donc 1 et x vaudra 0.

Continue interrompt l'exécution du tour de boucle en cours, et renvoie à l'instruction de fin du bloc d'instructions de la boucle, qui passe alors au tour suivant (ou s'arrête, si la condition d'arrêt est vraie).
Par exemple, avec le programme suivant :

Program test_continue;

Var
  i : Integer

Begin
  i := 0;
  while i < 13 do
    begin
      Inc(i);
      if i < 10 then Continue;
      WriteLn('i = ',i);
    end;
End.

on obtient comme résultat :

i = 10
i = 11
i = 12
i = 13

car la ligne

if i < 10 then Continue;

renvoie à la fin de la boucle si i est inférieur à 10, et renvoie donc au end; ,ce qui fait sauter le Writeln('i = ',i); et la boucle reprend au début tant que la condition de sortie reste fausse.

Le principe est le même pour les autres types de boucle.