Boucle DO ABAP : syntaxe, variantes et utilisation de sy-index

Catégorie
ABAP-Statements
Publié
Auteur
Johannes

L’instruction DO en ABAP est une construction de boucle utilisee pour executer un bloc d’instructions de maniere repetee. Elle existe principalement en deux variantes :

  1. Nombre fixe d’iterations : execute le bloc de boucle exactement <n> fois.
  2. Sortie conditionnelle de l’interieur : execute le bloc de boucle potentiellement indefiniment, jusqu’a ce que la boucle soit explicitement quittee par une instruction comme EXIT.

Un champ systeme utile dans les boucles DO est sy-index, qui compte automatiquement l’iteration de boucle actuelle (en commencant par 1).

Syntaxe

1. Nombre fixe d’iterations (DO n TIMES)

DO <n> TIMES.
 " Bloc d'instructions
 [Instruction1].
 [Instruction2].
 ...
 " Les instructions de controle comme CONTINUE, EXIT, CHECK sont possibles ici
ENDDO.
  • <n> : une expression numerique (literal, variable, constante - generalement de type I), qui indique le nombre d’iterations souhaitees. Si <n> est inferieur ou egal a zero, le bloc d’instructions n’est pas du tout execute.
  • sy-index : contient dans chaque iteration le numero d’iteration actuel (1, 2, 3, …, n).

2. Boucle avec sortie de l’interieur (DO.)

DO.
 " Bloc d'instructions
 [Instruction1].
 ...
 IF <condition_sortie>.
   EXIT. " Absolument necessaire !
 ENDIF.
 ...
ENDDO.
  • Cette variante n’a pas de condition de sortie integree. Elle s’execute theoriquement indefiniment.
  • Il est obligatoire d’inclure dans le bloc d’instructions une condition (IF) avec une instruction EXIT (ou RETURN dans les procedures) pour quitter la boucle et eviter une boucle infinie.
  • sy-index : compte aussi les iterations ici (1, 2, 3, …).

Fonctionnement et deroulement

DO <n> TIMES.

  1. La valeur de <n> est determinee.
  2. sy-index est mis a 1.
  3. Tant que sy-index est inferieur ou egal a <n> : a. Le bloc d’instructions est execute. b. sy-index est automatiquement incremente de 1.
  4. Si sy-index est superieur a <n>, la boucle se termine et l’execution continue apres ENDDO.

DO.

  1. sy-index est mis a 1.
  2. Le bloc d’instructions est execute.
  3. sy-index est automatiquement incremente de 1.
  4. Le controle revient toujours au debut du bloc d’instructions (apres DO.).
  5. La boucle n’est quittee que par une instruction EXIT explicite (ou RETURN etc.).

Instructions de controle dans DO

  • EXIT : termine toute la boucle DO (que ce soit DO n TIMES ou DO.) immediatement. L’execution continue apres ENDDO.
  • CONTINUE : saute le reste de l’iteration actuelle et passe au debut de l’iteration suivante (incremente sy-index, verifie eventuellement la condition TIMES).
  • CHECK <condition> : si <condition> est fausse, le reste de l’iteration actuelle est saute (se comporte comme CONTINUE).

Distinction avec WHILE et LOOP AT

  • WHILE <condition> : verifie la condition avant chaque iteration (controle en tete). Adapte quand le nombre d’iterations n’est pas fixe mais depend d’une condition.
  • LOOP AT : concu specifiquement pour l’iteration sur les lignes d’une table interne.
  • DO <n> TIMES : ideal quand le nombre de repetitions est connu a l’avance (boucle de comptage).
  • DO. : plus rare ; pour les cas ou la condition de sortie est complexe et mieux verifiee a l’interieur de la boucle ou plusieurs points de sortie existent.

Exemples

1. DO n TIMES - Repetition simple avec sy-index

DATA message TYPE string VALUE 'Bonjour'.


DO 4 TIMES.
  WRITE: / sy-index, '. Repetition:', message.
ENDDO.

Sortie :

         1 . Repetition: Bonjour
         2 . Repetition: Bonjour
         3 . Repetition: Bonjour
         4 . Repetition: Bonjour

2. DO. avec EXIT (sommation jusqu’a une limite)

DATA somme    TYPE i VALUE 0.
DATA ajout    TYPE i VALUE 0.
DATA maximum  TYPE i VALUE 50.


DO.
  ajout = ajout + 5.
  somme = somme + ajout.
  WRITE: / 'Iteration:', sy-index, ' | Ajoute:', ajout, ' | Somme:', somme.


  IF somme >= maximum.
    WRITE: / '-> Maximum atteint ou depasse. EXIT.'.
    EXIT. " Quitter la boucle
  ENDIF.


  IF sy-index > 10. " Sortie de securite
     WRITE: / '-> Limite de securite (10 iterations) atteinte. EXIT.'.
     EXIT.
  ENDIF.


ENDDO.


WRITE: / 'Boucle terminee. Somme finale:', somme.

Sortie possible :

Iteration:          1  | Ajoute:          5  | Somme:          5
Iteration:          2  | Ajoute:         10  | Somme:         15
Iteration:          3  | Ajoute:         15  | Somme:         30
Iteration:          4  | Ajoute:         20  | Somme:         50
-> Maximum atteint ou depasse. EXIT.
Boucle terminee. Somme finale:         50

3. DO n TIMES avec CONTINUE (sauter certaines iterations)

DO 6 TIMES.
  IF sy-index MOD 2 = 0. " Si sy-index est pair...
    WRITE: / 'Iteration', sy-index, 'sautee (nombre pair).'.
    CONTINUE.           " ...passer a l'iteration suivante
  ENDIF.
  WRITE: / 'Iteration', sy-index, 'traitee (nombre impair).'.
ENDDO.

Sortie :

Iteration          1 traitee (nombre impair).
Iteration          2 sautee (nombre pair).
Iteration          3 traitee (nombre impair).
Iteration          4 sautee (nombre pair).
Iteration          5 traitee (nombre impair).
Iteration          6 sautee (nombre pair).

Remarques importantes / Bonnes pratiques

  • Utilisez DO <n> TIMES quand vous savez exactement combien de fois une action doit etre repetee.
  • Soyez extremement prudent avec la syntaxe DO. sans TIMES. Assurez-vous absolument qu’il existe une condition EXIT atteignable, sinon vous creez une boucle infinie !
  • sy-index est votre allie dans les boucles DO pour suivre l’iteration actuelle.
  • Choisissez la construction de boucle (DO, WHILE, LOOP AT) qui represente le plus clairement et efficacement la logique de votre probleme.