Contrôle de boucle ABAP : L instruction CONTINUE dans DO, WHILE et LOOP AT

Catégorie
ABAP-Statements
Publié
Auteur
Johannes

L’instruction CONTINUE est une instruction de contrôle qui est utilisée exclusivement à l’intérieur de constructions de boucle (DO, WHILE, LOOP AT, et la boucle obsolète SELECT...ENDSELECT).

Son but est d’interrompre immédiatement l’exécution de l’itération de boucle en cours et de passer directement au début de l’itération suivante. Toutes les instructions qui se trouveraient dans le bloc de boucle après la commande CONTINUE sont sautées pour cette itération spécifique.

Important : CONTINUE ne termine pas toute la boucle (c’est ce que fait EXIT), mais fait seulement en sorte que l’itération en cours ne soit pas terminée et que la suivante commence à la place (si la condition de boucle le permet encore).

Syntaxe

La syntaxe est très simple :

CONTINUE.

Fonctionnement et comportement

Lorsque l’exécution du programme rencontre CONTINUE à l’intérieur d’une boucle :

  1. Toutes les instructions suivantes dans l’itération de boucle en cours sont ignorées.
  2. Le contrôle saute directement à la fin de l’itération en cours et initie le début de l’itération suivante. Cela signifie concrètement :
    • Pour DO ... ENDDO : Le compteur de boucle (sy-index) est incrémenté et la condition de boucle (par ex. TIMES) est vérifiée pour l’itération suivante.
    • Pour WHILE ... ENDWHILE : Le contrôle retourne à la ligne WHILE <condition> et la condition est réévaluée.
    • Pour LOOP AT ... ENDLOOP : Le système tente de traiter la ligne suivante de la table interne (met à jour sy-tabix, lit éventuellement dans la zone de travail/le symbole de champ).
    • Pour SELECT ... ENDSELECT (obsolète) : L’entrée de base de données correspondante suivante est récupérée.

Contexte

CONTINUE n’est valide et significatif qu’à l’intérieur des types de boucle mentionnés. En dehors d’une boucle, CONTINUE entraîne une erreur de syntaxe.

Distinction avec EXIT et CHECK

  • EXIT : Termine toute la boucle immédiatement. L’exécution continue après le ENDDO/ENDWHILE/ENDLOOP.
  • CHECK <condition>. : Est conditionnel. Seulement si <condition> est fausse, le reste de l’itération en cours est sauté (se comporte alors comme CONTINUE).
  • CONTINUE : Saute le reste de l’itération en cours inconditionnellement lorsque l’instruction est atteinte. La boucle continue cependant en principe.

Exemples

1. CONTINUE dans LOOP AT (Sauter certaines lignes)

TYPES: BEGIN OF ty_task,
         id          TYPE i,
         description TYPE string,
         status      TYPE c LENGTH 1, " O=Ouvert, C=Fermé
       END OF ty_task.
DATA: lt_tasks TYPE STANDARD TABLE OF ty_task,
      ls_task  TYPE ty_task.


APPEND VALUE #( id = 1 description = 'Tâche A' status = 'O' ) TO lt_tasks.
APPEND VALUE #( id = 2 description = 'Tâche B' status = 'C' ) TO lt_tasks.
APPEND VALUE #( id = 3 description = 'Tâche C' status = 'O' ) TO lt_tasks.
APPEND VALUE #( id = 4 description = 'Tâche D' status = 'C' ) TO lt_tasks.


WRITE: / 'Traitement des tâches ouvertes :'.
LOOP AT lt_tasks INTO ls_task.
  IF ls_task-status = 'C'. " Si la tâche est fermée...
    WRITE: / '-> Tâche', ls_task-id, 'est fermée, sautée (CONTINUE).'.
    CONTINUE.             " ... sauter le reste et prendre la tâche suivante
  ENDIF.


  " Ce code n'est exécuté que pour les tâches ouvertes ('O')
  WRITE: / '--> Traitement tâche :', ls_task-id, ls_task-description.
  " ... traitement réel ...
ENDLOOP.

Sortie :

Traitement des tâches ouvertes :
--> Traitement tâche :          1 Tâche A
-> Tâche          2 est fermée, sautée (CONTINUE).
--> Traitement tâche :          3 Tâche C
-> Tâche          4 est fermée, sautée (CONTINUE).

2. CONTINUE dans DO (Sauter certaines valeurs de compteur)

DO 10 TIMES.
  DATA(lv_index) = sy-index.


  IF lv_index > 3 AND lv_index < 7. " Sauter les itérations 4, 5, 6
    WRITE: / 'Itération', lv_index, 'est sautée.'.
    CONTINUE.
  ENDIF.


  WRITE: / 'Itération', lv_index, 'est traitée normalement.'.
ENDDO.

Sortie :

Itération          1 est traitée normalement.
Itération          2 est traitée normalement.
Itération          3 est traitée normalement.
Itération          4 est sautée.
Itération          5 est sautée.
Itération          6 est sautée.
Itération          7 est traitée normalement.
Itération          8 est traitée normalement.
Itération          9 est traitée normalement.
Itération         10 est traitée normalement.

3. CONTINUE dans WHILE

DATA counter TYPE i VALUE 0.


WHILE counter < 20.
  counter = counter + 1.


  " Exemple : Exécuter une action supplémentaire seulement tous les 5 pas
  IF counter MOD 5 <> 0. " Si le compteur N'EST PAS divisible par 5...
    CONTINUE.           " ... sauter le reste de cette itération
  ENDIF.


  " Cette action n'est exécutée que si counter est 5, 10, 15, 20
  WRITE: / 'Action supplémentaire à la valeur du compteur :', counter.


ENDWHILE.

Sortie :

Action supplémentaire à la valeur du compteur :          5
Action supplémentaire à la valeur du compteur :         10
Action supplémentaire à la valeur du compteur :         15
Action supplémentaire à la valeur du compteur :         20

Notes importantes / Bonnes pratiques

  • CONTINUE est un outil utile pour rendre le code à l’intérieur des boucles plus clair en traitant et sautant certains cas de manière anticipée.
  • Il est presque toujours utilisé à l’intérieur d’une structure IF pour rendre le saut dépendant d’une condition (IF <Condition> THEN CONTINUE. ENDIF.).
  • Assurez-vous que l’utilisation de CONTINUE n’affecte pas la lisibilité du code. Parfois, une restructuration de la logique IF sans CONTINUE peut être plus claire.
  • Veillez à ce que les variables de boucle (comme les compteurs dans les boucles WHILE) soient correctement modifiées même lorsque CONTINUE est utilisé, pour éviter les boucles infinies.