10.4    Schleifen 

Schleifen, auch Wiederholungen genannt, führen Anweisungsblöcke mehrfach aus. Hierbei werden Schleifen ohne Bedingung und mit Bedingung unterschieden.

 

10.4.1    SELECT-Schleife 

Mit der SELECT-Anweisung kennen Sie bereits die erste Schleife, bei der es die Möglichkeit gibt, eine Bedingung mit der Anweisung zu verknüpfen. Wenn Sie in einer Tabelle Sätze lesen, können Sie über eine Selektionsbedingung filtern und nur die Sätze lesen, die diese Bedingung erfüllen.

Möchten Sie in der Teilnehmertabelle nur die Sätze lesen, bei denen als Kurstitel »Netzwerktechnik« steht, schreiben Sie:

SELECT * FROM zteilnehmer02
         INTO wa_zteilnehmer02
         WHERE zzkurstitel = 'Netzwerktechnik'.
  tz_netzwerktechnik = tz_netzwerktechnik + 1.
ENDSELECT.

Der Anweisungsblock, der hier nur aus einer Zeile besteht – hinter der Bedingung, die die Teilnehmeranzahl erhöht –, wird nur für die Treffersätze ausgeführt, anderenfalls nicht.

 

10.4.2    DO-Schleife 

Die Struktur der DO-Schleife beginnt mit der Anweisung DO und endet mit der Anweisung ENDDO. Dazwischen steht der zu wiederholende Anweisungsblock.

DO.
* Anweisungsblock
ENDDO.

Bei der DO-Schleife ist zunächst wichtig, dass der Anweisungsblock in der Struktur das erste Mal angelaufen wird, ohne dass das System vorher eine Bedingung prüft. Selbst wenn Sie ein Kriterium zum Verlassen der Schleife einbauen, werden die Kommandos vor dem Abbruchkriterium mindestens einmal ausgeführt. Der Ort der Abbruchbedingung im Anweisungsblock ist deshalb für die Programmlogik sehr bedeutsam.

Um die Anzahl der Schleifendurchläufe zu begrenzen, können Sie eine Obergrenze von Durchläufen festlegen. Möchten Sie, dass eine Schleife maximal zwölfmal durchlaufen wird, schreiben Sie:

DO 12 TIMES.

Anstatt die Anzahl der Durchläufe fix als Zahl anzugeben, können Sie diesen Wert auch in einer Variablen hinterlegen. Weisen Sie beispielsweise der Variablen MONATE vom Typ i den Wert 6 zu, lautet die Anweisung:

DO monate TIMES.

Die Schleife wird nun sechsmal durchlaufen, danach wird das Programm mit der ersten Anweisung nach ENDDO fortgesetzt.

Während der Anweisungsblock in der Schleife wiederholt wird, führt das System automatisch einen Schleifenzähler mit. Im Feld SY-INDEX steht zu jedem Schleifendurchlauf der aktuelle Wert, beim ersten Durchlauf die 1, beim zweiten Durchlauf die 2 etc. Dieser Schleifenzähler kann sowohl im Debugging-Modus zur Fehlersuche als auch als Abbruchkriterium nützlich sein.

DO-Schleifen sind schachtelbar, und SY-INDEX wird im Fall einer Schachtelung vom System getrennt für jede Ebene extra geführt. Doch auch hier sollten Sie besondere Vorsicht walten lassen: Durch das Schachteln von Schleifen kann sehr schnell eine erhebliche Systembelastung entstehen, z. B. mit folgendem Konstrukt:

DO 50 TIMES.
* Anweisungsblock_1
  DO 100 TIMES.
*   Anweisungsblock_2
  ENDDO.
ENDDO.

In diesem Beispiel gibt es eine innere und eine äußere Schleife. Die äußere Schleife wird 50-mal ausgeführt. Zu jedem Durchlauf des Anweisungsblocks 1 wird die innere Schleife 100-mal durchlaufen, sodass Anweisungsblock_2 somit 100 mal 50, d. h. 5.000-mal ausgeführt wird.

Zum Verständnis, wie schnell die Anzahl der Schleifendurchläufe ausufern kann, hilft ein Blick auf die Uhr – und zwar auf deren Ablauflogik. Ein Tag hat 24 Stunden, eine Stunde hat 60 Minuten und eine Minute 60 Sekunden. Bildet man diese »Programmlogik« in ABAP ab, ergeben sich drei geschachtelte Schleifen. Im Kern steht ein Anweisungsblock, der die berechnete Zeit zur Anzeige übermittelt und in diesem Beispiel nur aus einer Zeile besteht, nämlich der WRITE-Anweisung als Stellvertreter für die Anzeigeaufbereitung:

DO 24 TIMES.
  min = 0.
  DO 60 TIMES.
    sek = 0.
    DO 60 TIMES.
      WRITE: / std, min, sek.
      sek = sek + 1.
    ENDDO.
    min = min + 1.
  ENDDO.
  std = std + 1.
ENDDO.

Der Verarbeitungsblock im Kern zur Anzeige der Zeit wird an einem Tag 60 mal 24, d. h. 86.400-mal durchlaufen. Dabei würden 86.400 Zeilen in einer Liste ausgegeben. Unterstellt man 60 Zeilen pro Seite, wäre dies eine Liste mit 1.440 Seiten! Damit es erst gar nicht so weit kommt, sollten Sie wohlüberlegt vorgehen, Schleifen gründlich planen, diese mit dem Debugger verfolgen und Abbruchbedingungen einbauen.

 

10.4.3    WHILE-Schleife 

Im Unterschied zur DO-Schleife prüft die WHILE-Schleife eine Bedingung, bevor der Anweisungsblock zum ersten Mal ausgeführt wird. Gilt die Bedingung, wird der Anweisungsblock ausgeführt. Danach prüft das System wieder, ob die Bedingung gültig ist. Falls ja, wird der Anweisungsblock noch einmal ausgeführt etc. Das wiederholt sich endlos, es sei denn, die Bedingung gilt nicht mehr, weil sie beispielsweise im Anweisungsblock verändert oder ein anderes Abbruchkriterium erreicht wurde.

Die Syntax der WHILE-Schleife ist relativ einfach. Die Struktur beginnt mit der Anweisung WHILE und einer Bedingung, anschließend folgt der Anweisungsblock, der ausgeführt wird, falls die Bedingung erfüllt ist. Danach steht für das Strukturende die Anweisung ENDWHILE.

WHILE Bedingung.
* Anweisungsblock
ENDWHILE.

Im folgenden Beispiel läuft eine Stoppuhr rückwärts und startet mit einer Vorlauffrist in Sekunden. Ist der Wert für die Sekunden auf 0 heruntergezählt, soll der Startschuss erfolgen. Lässt man einmal das Problem beiseite, wie die Anzahl von Quarzschwingungen gezählt wird, damit eine Sekunde auch genau die richtige Zeiteinheit im Programm abbildet, und betrachtet nur den Anteil der Programmierlogik, dann gilt: Solange die Sekunden größer sind als 0, soll eine weitere Sekunde abgezogen werden. Die Anweisungen für die Schleife lauten:

WHILE sek > 0.
  WRITE: / sek.
  sek = sek - 1.
ENDWHILE.

Natürlich muss vor der Schleife der Wert für Sekunden gesetzt sein, und es wird geprüft, ob der Feldinhalt größer ist als 0. Falls ja, wird der Wert ausgegeben und um 1 vermindert. Dann wird erneut geprüft, ob der Wert größer ist als 0 etc. Hat das Feld SEK den Wert 0 erreicht, wird die Anweisung nicht mehr ausgeführt und zu ENDWHILE verzweigt. Anschließend setzt das System die Programmausführung mit der ersten Anweisung nach ENDWHILE fort.

Die Anzahl der Schleifendurchläufe wird wie bei der DO-Schleife im Feld SY-INDEX protokolliert. SY-INDEX kann im Anweisungsblock gelesen und für die Programmsteuerung ausgewertet werden.

Natürlich können Sie WHILE-Schleifen, ebenso wie DO-Schleifen, auch schachteln. Die Hinweise, die wir hierzu bei den DO-Schleifen gegeben haben, gelten analog auch für die WHILE-Schleifen.

 

10.4.4    Abbruchanweisungen für Schleifen 

Zum Abbruch von Schleifen kennt ABAP mehrere verschiedene Abbruchanweisungen.

CONTINUE

Die erste dieser Anweisungen, CONTINUE, ist ausschließlich zum Abbruch eines Anweisungsblocks innerhalb einer Schleife gedacht. Steht die CONTINUE-Anweisung mitten in einem Anweisungsblock, wird der Rest der Anweisungen dieses Blocks nicht mehr ausgeführt und ein neuer Schleifendurchlauf gestartet, falls die Bedingungen für einen neuen Durchlauf noch gelten. Da das Kommando selbst keine Bedingung prüft, packt man es oft in eine Verzweigung, über deren Bedingung der Programmlauf gesteuert wird. Falls die Bedingung erfüllt ist, wird das CONTINUE-Kommando ausgeführt, der Anweisungsblock beendet, ein neuer Durchlauf geprüft und eventuell gestartet. Die Struktur der CONTINUE-Anweisung ist relativ einfach:

IF Bedingung_1.
  CONTINUE.
ENDIF.

Um in der Teilnehmertabelle die Sätze der Kursteilnehmer zu verarbeiten, die nach dem 01.01.1970 geboren sind, schreiben Sie beispielsweise:

SELECT * FROM zteilnehmer02 INTO wa_zteilnehmer02.
  IF wa_zteilnehmer02-tgeburtsdatum LT '19700101'.
    CONTINUE.
  ENDIF.
* Anweisungsblock_1
ENDSELECT.

Die Bedingung nach der IF-Anweisung ist ein logischer Ausdruck. LT ist dabei der Operand für »kleiner als«, mit dem die beiden Werte verglichen werden. Liest das System einen Satz mit einem Geburtsdatum vor dem 01.01.1970, wird der – hier nicht näher erklärte – Anweisungsblock_1 nicht ausgeführt, sondern sofort der nächste Satz gelesen. Nur die Sätze, bei denen das Geburtsdatum am oder nach dem 01.01.1970 liegt, gelangen in die Verarbeitung des Anweisungsblocks.

CHECK

Die zweite Abbruchanweisung CHECK ist mächtiger: Falls die Anweisung in einer Schleife ausgeführt wird, wird die Verarbeitung des Anweisungsblocks beendet und der nächste Schleifendurchlauf gestartet, sofern die Bedingungen hierfür noch gelten. In diesem Sinn könnte man die Anweisung CHECK als Kombination aus den Anweisungen IF und CONTINUE bezeichnen. Sie schreiben einfach:

CHECK Bedingung.

Ist die Bedingung erfüllt, werden alle Anweisungen des Anweisungsblocks nach dem CHECK-Kommando ausgeführt. Ist die Bedingung hingegen nicht erfüllt, werden alle nachstehenden Kommandos des Anweisungsblocks übersprungen, und nach Prüfung der Bedingungen wird ein neuer Schleifendurchlauf gestartet.

Interessiert Sie beispielsweise die Verteilung der Kursteilnehmer nach Geschlecht, könnten Sie die Sätze entsprechend dem Geschlechtsschlüssel selektieren:

SELECT * FROM zteilnehmer02 INTO wa_zteilnehmer02.
  CHECK wa_zteilnehmer02-tgeschlecht = 'W'.
* Anweisungsblock
ENDSELECT.

In der Schleife wird geprüft, ob die Bedingung des Geschlechtsschlüssels erfüllt ist. Falls ja, wird der Anweisungsblock ausgeführt; falls nein, wird der nächste Satz gelesen und geprüft.

EXIT

Die dritte Anweisung EXIT ist ebenfalls mächtig: Sie beendet nicht nur den Anweisungsblock, sondern die Schleifenverarbeitung an sich. Das System verzweigt zum Ende der Struktur und setzt die Programmausführung mit der ersten Anweisung nach dem Strukturende fort. Das Kommando bezieht sich hierbei immer auf die Ebene, auf der es ausgeführt wird: Es beendet die Verarbeitung auf dieser Ebene und bewirkt die Programmfortsetzung auf der nächsthöheren, äußeren Ebene.

Steht die ausgeführte EXIT-Anweisung bei zwei geschachtelten Schleifen beispielsweise in der inneren Schleife, wird diese beendet und das Programm mit der Anweisung nach dem Strukturende der inneren Schleife fortgesetzt, d. h. eine Ebene höher in der äußeren Schleife. Steht die EXIT-Anweisung hingegen in der äußeren Schleife und wird dort ausgeführt, wird die äußere Schleife beendet und mit der ersten Anweisung nach ihrem Strukturende fortgesetzt.

Zur Verdeutlichung soll wieder das Zeitmesserbeispiel dienen: Dieses Mal lassen Sie den Zeitmesser aber nicht durchlaufen, sondern Sie brechen die Schleifen mit der EXIT-Anweisung ab, um die Wirkung zu beobachten. In der innersten der drei Schleifen steht ein Anweisungsblock. Hat SY-INDEX für die innerste Schleife den Wert 3, wird die innerste Schleife beendet und zur mittleren Schleife verzweigt. Der Anweisungsblock wurde allerdings zuvor noch ausgeführt. Hat in der mittleren Schleife SY-INDEX den Wert 3, werden die nachfolgenden Anweisungen der mittleren Schleife nicht mehr ausgeführt; die dritte Schleife und ihr Anweisungsblock werden übersprungen. Das System geht zur äußeren Schleife und startet den nächsten Schleifendurchlauf auf dieser Ebene. Hat auch der SY-INDEX der äußeren Schleife den Wert 3, wird auch diese Schleife beendet.

DO 24 TIMES.
  IF sy-index = 3.
    EXIT.
  ENDIF.
  min = 0.
  DO 60 TIMES.
    IF sy-index = 3.
      EXIT.
    ENDIF.
    sek = 0.
    DO 60 TIMES.
*     Anweisungsblock
      sek = sek + 1.
      IF sy-index = 3.
        EXIT.
      ENDIF.
    ENDDO.
    min = min + 1.
  ENDDO.
  std = std + 1.
ENDDO.

Wie bei der Anweisung CHECK ist die Wirkung der Anweisung EXIT abhängig von der Struktur, d. h. der Ebene, auf der sie ausgeführt wird. Wird die Anweisung in einer Schleife ausgeführt, wird die Schleife abgebrochen. Wird die Anweisung in einer Methode oder einem Unterprogramm ausgeführt, wird der Verarbeitungsblock abgebrochen und in der übergeordneten Struktur weitergearbeitet. Das gilt auch für Ereignisse: Ein ausgeführtes EXIT-Kommando in einem Ereignis beendet das Ereignis, und das System fährt mit der Verarbeitung des nächsten Ereignisses fort. Diese Doppelfunktion des EXIT-Kommandos kann leicht zu Fehlern führen, wenn eine EXIT-Anweisung, die in einer Schleife stand, nach einer Programmänderung außerhalb der Schleife steht und ungewollt zum Verlassen des Unterprogramms oder der Methode führt. Um die Absicht des Entwicklers eindeutig kenntlich zu machen, sollte zum Verlassen eines Unterprogramms oder einer Methode die RETURN-Anweisung verwendet werden.

Sind keine weiteren Ereignisse deklariert und keine Anweisungen hierfür vorgesehen, wird das Programm beendet. Im Zusammenhang mit dem Beenden von Ereignissen gibt es noch weitere Möglichkeiten, auf die hier aber nicht weiter eingegangen werden soll.