Instruction EXIT ABAP : Terminer immédiatement les boucles et sous-programmes

Catégorie
ABAP-Statements
Publié
Auteur
Johannes

L’instruction EXIT est une instruction de contrôle en ABAP qui sert à terminer immédiatement et inconditionnellement l’exécution d’un bloc de traitement spécifique. Les principaux cas d’utilisation de EXIT sont :

  1. Terminer des boucles : Quitter prématurément une boucle DO, WHILE ou LOOP AT complète.
  2. Terminer des sous-programmes : Quitter prématurément un sous-programme FORM ... ENDFORM.

Contrairement à CONTINUE (qui ne saute que l’itération courante) ou CHECK (qui saute ou quitte conditionnellement), EXIT termine définitivement le bloc englobant (boucle ou FORM) en entier.

Syntaxe

La syntaxe de base et la plus couramment utilisée est :

EXIT.

Il existe également des formes spécialisées comme EXIT FROM STEP-LOOP ou EXIT FROM SQL, mais elles sont rarement pertinentes dans le développement ABAP moderne.

Fonctionnement et comportement

Le comportement de EXIT dépend du contexte :

1. À l’intérieur d’une boucle (DO, WHILE, LOOP AT)

  • EXIT termine immédiatement la boucle entière, quel que soit le nombre d’itérations restantes prévues.
  • L’exécution du programme continue avec la première instruction après l’instruction de fermeture de la boucle (ENDDO, ENDWHILE, ENDLOOP).
  • Dans le cas de boucles imbriquées (une boucle à l’intérieur d’une autre), EXIT termine toujours uniquement la boucle la plus interne dans laquelle il se trouve directement.

2. À l’intérieur d’un sous-programme (FORM ... ENDFORM)

  • EXIT termine immédiatement le sous-programme entier.
  • Le contrôle retourne à la partie appelante du programme, à l’instruction directement après l’appel PERFORM.

3. Dans d’autres contextes

  • L’utilisation de EXIT directement dans des blocs d’événements (par ex. START-OF-SELECTION) pour terminer le programme entier est techniquement possible, mais est considérée comme mauvais style de programmation et obsolète. Pour cela, il faut utiliser LEAVE PROGRAM.
  • Dans les méthodes ABAP modernes (METHOD ... ENDMETHOD), EXIT n’est pas utilisé pour quitter la méthode. Pour cela, l’instruction RETURN est prévue.

Distinction avec d’autres instructions de contrôle

Il est important de distinguer EXIT des instructions similaires :

  • CONTINUE : (Uniquement dans les boucles) Saute le reste de l’itération courante et démarre l’itération suivante. La boucle elle-même n’est pas terminée.
  • CHECK <condition>. : (Dans les boucles/FORMs) Saute le reste de l’itération (CONTINUE) ou quitte le FORM (EXIT), mais seulement si la condition est fausse.
  • RETURN : (Dans les méthodes/modules fonctionnels) Termine l’exécution de la méthode ou du module fonctionnel et retourne à l’appelant.
  • LEAVE PROGRAM : Termine le programme ABAP entier.
  • EXIT : Termine inconditionnellement la boucle entière ou le FORM entier.

Exemples

1. EXIT dans LOOP AT (Arrêter une recherche)

DATA: product_list TYPE STANDARD TABLE OF string,
      search_item  TYPE string VALUE 'Banana'.


APPEND 'Apple' TO product_list.
APPEND 'Pear' TO product_list.
APPEND 'Banana' TO product_list.
APPEND 'Orange' TO product_list.


WRITE: / 'Searching for:', search_item.
DATA found TYPE abap_bool VALUE abap_false.


LOOP AT product_list INTO DATA(product).
  WRITE: / 'Checking:', product.
  IF product = search_item.
    found = abap_true.
    WRITE: ' -> Found! Exiting loop.'.
    EXIT. " Exit the LOOP AT statement
  ENDIF.
ENDLOOP.


IF found = abap_true.
  WRITE: / 'Item was found in the list.'.
ELSE.
  WRITE: / 'Item was not found.'.
ENDIF.
WRITE: / 'Processing continues after the loop.'.

Sortie :

Searching for: Banana
Checking: Apple
Checking: Pear
Checking: Banana -> Found! Exiting loop.
Item was found in the list.
Processing continues after the loop.

2. EXIT dans WHILE (Condition dans le corps de la boucle)

DATA counter TYPE i VALUE 0.
DATA limit TYPE i VALUE 5.


WHILE counter < 10. " Théoriquement jusqu'à 9
  counter = counter + 1.
  WRITE: / 'WHILE loop, counter:', counter.


  IF counter = limit.
    WRITE: ' -> Limit reached, exiting WHILE loop.'.
    EXIT. " Exit the WHILE loop
  ENDIF.


  " Cette partie n'est plus atteinte après EXIT
  WRITE: ' -> Processing normally.'.
ENDWHILE.


WRITE: / 'After WHILE loop.'.

Sortie :

WHILE loop, counter:          1 -> Processing normally.
WHILE loop, counter:          2 -> Processing normally.
WHILE loop, counter:          3 -> Processing normally.
WHILE loop, counter:          4 -> Processing normally.
WHILE loop, counter:          5 -> Limit reached, exiting WHILE loop.
After WHILE loop.

3. EXIT dans FORM (Quitter un sous-programme)

START-OF-SELECTION.
  PERFORM check_value USING 50.
  PERFORM check_value USING -10. " Cas d'erreur
  PERFORM check_value USING 100.


FORM check_value USING iv_value TYPE i.
  WRITE: / 'FORM entered with value:', iv_value.


  IF iv_value < 0.
    WRITE: ' -> Invalid value, exiting FORM.'.
    EXIT. " Exit the FORM subroutine
  ENDIF.


  " Cette partie n'est atteinte que pour les valeurs positives
  WRITE: ' -> Value is valid, processing...'.
ENDFORM.


WRITE: / 'Main program continues.'.

Sortie :

FORM entered with value:         50
 -> Value is valid, processing...
FORM entered with value:        -10
 -> Invalid value, exiting FORM.
FORM entered with value:        100
 -> Value is valid, processing...
Main program continues.

4. EXIT dans des boucles imbriquées

DO 2 TIMES. " Outer loop
  DATA(outer_idx) = sy-index.
  WRITE: / 'Outer Loop:', outer_idx.
  DO 3 TIMES. " Inner loop
    DATA(inner_idx) = sy-index.
    WRITE: |  Inner Loop: { inner_idx }|.
    IF outer_idx = 1 AND inner_idx = 2.
      WRITE: '  -> Exiting INNER loop!'.
      EXIT. " Exits the inner DO loop only
    ENDIF.
  ENDDO. " End of inner loop
  WRITE: | -> After Inner Loop (Outer: { outer_idx })|.
ENDDO. " End of outer loop

Sortie :

Outer Loop:          1
  Inner Loop:          1
  Inner Loop:          2  -> Exiting INNER loop!
 -> After Inner Loop (Outer:          1)
Outer Loop:          2
  Inner Loop:          1
  Inner Loop:          2
  Inner Loop:          3
 -> After Inner Loop (Outer:          2)

Remarques importantes / Bonnes pratiques

  • EXIT est inconditionnel. Il termine le bloc immédiatement lorsqu’il est atteint.
  • Par conséquent, EXIT est presque exclusivement placé à l’intérieur d’une instruction IF pour rendre la terminaison dépendante d’une condition spécifique (IF <condition> THEN EXIT. ENDIF.).
  • Utilisez EXIT de manière ciblée lorsque la poursuite du traitement de la boucle ou du FORM n’a plus de sens ou qu’une interruption est nécessaire (par ex. après avoir trouvé un élément, en cas d’erreur).
  • Connaissez les alternatives (CONTINUE, CHECK, RETURN, LEAVE PROGRAM) et utilisez-les selon leur objectif.