Modernes ABAP Cheat Sheet – ABAP 7.40

von

    Mit ABAP 7.40 wurden zahlreiche neue Sprachkonstrukte eingeführt, die den Code kompakter, flexibler und lesbarer machen. Besonders Inline-Deklarationen, neue Operatoren und verbesserte Tabellenverarbeitung vereinfachen viele gängige Programmieraufgaben. In diesem Artikel werfen wir einen Blick auf einige dieser neuen Features, darunter DATA() für Inline-Deklarationen, CONV für Typkonvertierungen, REDUCE für Berechnungen über interne Tabellen und viele mehr. Durch diese Verbesserungen wird nicht nur der Entwicklungsaufwand reduziert, sondern auch die Wartbarkeit des Codes erheblich erhöht.

    Wenn du noch tiefer in die Welt der Konstruktor-Ausdrücke und -Operatoren in ABAP 7.40 eintauchen möchtest, findest Du in im Artikel „Die wichtigsten Konstruktor Operatoren in ABAP“ eine umfassende Erklärung mit zahlreichen praktischen Beispielen. Ich zeige dir nicht nur die Syntax und Funktionsweise, sondern auch frühere Alternativen, damit du die Vorteile der neuen Operatoren optimal nutzen kannst.

    Inhaltsverzeichnis Anzeigen

    Inline-Deklaration – DATA

    Ab ABAP 7.40 SP2

    Mit Inline-Deklarationen können Variablen genau dort definiert werden, wo sie erstmals verwendet werden, also dort, wo ihnen zum ersten Mal ein Wert zugewiesen wird. In vielen Fällen ergibt sich der Datentyp einer Variablen bereits aus dem Kontext, was den Code kompakter und lesbarer macht.

    Mit DATA(<Variable>) kann eine Variable direkt an der Stelle definiert werden, an der sie benötigt wird.

    LOOP AT lt_tabelle INTO DATA(ls_struktur).
    ...
ENDLOOP.

    Der Hauptvorteil der Inline-Deklaration liegt neben dem kompakteren Code in der größeren Flexibilität. Wenn sich die Feldliste ändert, wird der Datentyp automatisch angepasst. Besonders bei JOIN-Operationen gibt es oft keine geeignete Strukturdefinition.

    SELECT *
  FROM spfli
  INTO TABLE @DATA(lt_spfli).

    Field-Symbole können ebenfalls mit Inline-Deklarationen einem bestehenden Speicherbereich zugewiesen werden.

    LOOP AT ... ASSIGNING FIELD-SYMBOL(<fs_struktur>).

READ TABLE ... ASSIGNING FIELD-SYMBOL(<fs_struktur2>) ...

    Konvertierung Datentyp – CONV

    Ab ABAP 7.40

    Mit dem CONV-Operator lassen sich Datentypen unkompliziert konvertieren. Das ist besonders hilfreich bei Methodenparametern, wenn der Inhalt einer Variablen passt, aber der Datentyp nicht.

    DATA lv_text2 TYPE char255.
DATA(lv_xstr2) = cl_abap_codepage=>convert_to( source = CONV #( lv_text2 ) ).

methode( TEXT = CONV #( sy-datum ) ).

    Referenzvariablen mit CAST hoch- und runtercasten

    Ab ABAP 7.40

    Früher wurde ein Upcast durch eine einfache Zuweisung (=) durchgeführt, der Downcast mit ?=. Dies erforderte oft eine Hilfsvariable. Der CAST-Operator macht dies kompakter:

    DATA:
  lo_unterklasse TYPE REF TO zcl_unterklasse,
  lo_oberklasse TYPE REF TO zcl_oberklasse.

lo_oberklasse = CAST #( lo_unterklasse ).

DATA(lo_oberklasse2) = CAST zcl_oberklasse( lo_unterklasse ).

    Fallunterscheidung – COND und SWITCH

    Ab ABAP 7.40 SP2

    Diese Konstruktor-Ausdrücke ähneln der CASE-Anweisung in SQL.

    cl_demo_output=>display( 
  |Hallo { SWITCH #( lv_alter
                    WHEN 'F' THEN 'Frau'
                    WHEN 'M' THEN 'Herr'
                    ELSE '' )
              } { lv_name } | ).

    Komplexere Bedingungen mit COND:

    cl_demo_output=>display( |Der Status ist { COND #( 
  WHEN lv_prio > 3 AND lv_faellig_bis <= SY-DATUM THEN 'Kritisch'.
  WHEN lv_prio > 2 THEN 'Mittel'.
  ELSE 'Niedrig' ) }| ).

    Werte aus internen Tabellen berechnen – REDUCE

    Ab ABAP 7.40

    Der REDUCE-Operator berechnet Werte durch Iteration über interne Tabellen.

    *---------------------------------------------------------------------*
* Mit implizitem Datentyp
*---------------------------------------------------------------------*
DATA(lv_sum) = REDUCE #( INIT s = 0
                         FOR  i = 1 UNTIL i > 100
                         NEXT s = s + i ).
*---------------------------------------------------------------------*
* Mit angegebenem Datentyp
*---------------------------------------------------------------------*
DATA(lv_sum2) = REDUCE i( INIT s = 0
                         FOR  i = 1 UNTIL i > 100
                         NEXT s = s + i ).

    Interne Tabellen filtern – FILTER

    Ab ABAP 7.40

    Der FILTER-Operator erstellt interne Tabellen aus bestehenden Tabellen durch Filterung.

    DATA lt_daten TYPE SORTED TABLE OF I_CountryText WITH UNIQUE KEY LANGUAGE COUNTRY.
SELECT * FROM i_countrytext INTO TABLE @lt_daten.
cl_demo_output=>display( FILTER #( lt_daten WHERE LANGUAGE = 'D' ) ).
    DATA lt_daten TYPE SORTED TABLE OF I_CountryText WITH UNIQUE KEY COUNTRY.
DATA(lt_filter) = VALUE #( ( COUNTRY = 'DE' )
                           ( COUNTRY = 'US' ) ).
SELECT * FROM i_countrytext WHERE LANGUAGE = 'D' INTO TABLE @lt_daten.
cl_demo_output=>display( FILTER #( lt_daten IN lt_filter WHERE COUNTRY = COUNTRY ) ).

    Daten kopieren – CORRESPONDING

    Ab ABAP 7.40 SP5

    CORRESPONDING ähnelt MOVE-CORRESPONDING und kopiert Daten mit gleichen Feldnamen.

    TYPES: BEGIN OF lty_itab,
         carrid     TYPE sflight-carrid,
         connid     TYPE sflight-connid,
         flight_on  TYPE sflight-fldate,
         paymentsum TYPE int8,
       END OF lty_itab.

DATA: ls_sflight TYPE sflight,
      ls_itab    TYPE lty_Itab,
      lt_sflight TYPE TABLE OF sflight,
      lt_itab    TYPE STANDARD TABLE OF lty_itab.

SELECT * FROM sflight INTO TABLE lt_sflight.

lt_itab = CORRESPONDING #(
          lt_sflight MAPPING carrid = carrid
                            connid = connid
                            flight_on = fldate
                            EXCEPT paymentsum
                            ).

cl_demo_output=>display( lt_itab ).

    Tabellenausdrücke

    Ab ABAP 7.40

    Tabellenausdrücke erlauben einen direkteren Zugriff auf Tabellenzeilen.

    DATA: lt_values  TYPE SORTED TABLE OF zdemo_value WITH UNIQUE KEY id.

lt_values = VALUE #( ( id = 1 value = 'Test1' )
                     ( id = 2 value = 'Test2' )
                     ( id = 3 value = 'Test3' )
                     ( id = 4 value = 'Test4' )
                     ( id = 5 value = 'Test5' )
                     ( id = 6 value = 'Test6' ) ).

TRY.
    DATA(ls_value) = lt_values[ value = 'Test2' ].
    DATA(lv_value) = ls_value-value.
  CATCH cx_sy_itab_line_not_found.
    cl_demo_output=>display( 'Line not found' ).
ENDTRY.

cl_demo_output=>display( lv_value ).

    Gruppenverarbeitung

    Ab ABAP 7.40 SP8

    Die neue Gruppenverarbeitung ersetzt AT NEW/END durch GROUP BY in LOOP-Anweisungen.

    DATA: lt_values  TYPE SORTED TABLE OF zdemo_value WITH UNIQUE KEY id.

lt_values = VALUE #( ( id = 1 value = 'Test1' )
                    ( id = 2 value = 'Test1' )
                     ( id = 3 value = 'Test1' )
                     ( id = 4 value = 'Test2' )
                     ( id = 5 value = 'Test2' )
                     ( id = 6 value = 'Test3' ) ).

LOOP AT lt_values INTO DATA(ls_value)
  GROUP BY ls_value-value INTO DATA(ls_value_grouped).
  WRITE: / ls_value_grouped.
ENDLOOP.

    Verkettung Zeichenketten – &&

    Ab ABAP 7.02

    Strings lassen sich mit dem Operator && elegant verketten, ohne auf CONCATENATE und eine Hilfsvariable zurückgreifen zu müssen.

    cl_demo_output=>display( `Es ist das Jahr ` && sy-datum(4) `.` ).

    Beim Zusammenstellen von Strings, beispielsweise für HTML-Generierung, ist &&= eine kompakte Alternative zu CONCATENATE.

    lv_html &&= `<b>Hallo</b>`.

    String Templates

    Ab ABAP 7.02

    String-Templates sind Ausdrücke, die einen Zeichenstring erzeugen. Sie beginnen und enden mit | und können eingebettete Ausdrücke enthalten.

    cl_demo_output=>display( |Heute: { sy-datum DATE = USER }| ).

    Zusätzlich unterstützen String-Templates Formatierungsoptionen wie:

    • WIDTH = <Länge> (Breite in Zeichen)
    • ALIGN = <Ausrichtung> (LEFT, RIGHT oder CENTER)
    • DATE = USER (Datumsformat gemäß Benutzerstammsatz)
    • TIME = USER (Zeitformat gemäß Benutzerstammsatz)
    " Beispiel
cl_demo_output=>display( |Heute ist { sy-datum WIDTH = 10 ALIGN = RIGHT }| ).

    Enumerationen

    Ab ABAP 7.51

    Mit Enumerationen lassen sich typsichere Werte definieren, wodurch Fehler bereits zur Designzeit erkannt werden.

    " Definition
TYPES: BEGIN OF ENUM eColour,
          Black,
          White,
          Red,
          Green,
          Blue,
       END OF ENUM eColour.

"Verwendung
DATA MyColour TYPE eColour.
MyColour = Blue.

    Tabellen, Struktur und Objekte erzeugen – VALUE und NEW

    Ab ABAP 7.40

    Mit den Operatoren VALUE und NEW lassen sich Daten und Objekte effizient erzeugen. Während VALUE direkt Werte liefert, gibt NEW eine Referenz auf das erstellte Objekt zurück. Werden keine Parameter übergeben, erzeugen beide Operatoren leere Datenobjekte.

    Beim Erstellen von Strukturen können die einzelnen Komponenten direkt als Parameter übergeben werden. Nicht zugewiesene Komponenten erhalten ihren Initialwert.

    DATA(ls_zeile) = VALUE tadir( obj_name = 'ZCL_DEMO' object = 'CLAS' ).

    Einzelne Zeilen einer internen Tabelle werden in runden Klammern eingeschlossen:

    DATA lt_zeitraum TYPE RANGE OF dats.
lt_zeitraum = VALUE #( ( sign = 'I' option = 'EQ' low = '20250101' )
                     ( sign = 'I' option = 'EQ' low = '20251231' ) ).

    Gemeinsame Komponenten können vor den runden Klammern definiert werden:

    lt_zeitraum = VALUE #( sign = 'I' option = 'EQ' ( low = '20250101' )
                                               ( low = '20251231' ) ).

    Mit BASE kann eine bestehende Struktur oder Tabelle als Ausgangswert festgelegt werden. Unzugewiesene Komponenten übernehmen dann die Werte dieser Basisstruktur.

    Für Strukturen:

    lt_zeitraum_neu = VALUE #( BASE DateRange
                      ( sign = 'I' option = 'EQ' low = '20250101' ) ).

    Für interne Tabellen entspricht dies einem APPEND:

    lt_zeitraum_neu = VALUE #( BASE DateRange ( low = '20250101' ) ).

    Innerhalb des VALUE-Operators können auch FOR-Schleifen verwendet werden, wie sie beim REDUCE-Operator zum Einsatz kommen.

    Instanzen von Klassen lassen sich mit NEW erzeugen:

    NEW <Klasse>( <Konstruktorparameter> ).

    LINE_EXISTS

    AB ABAP 7.40 SP2

    Um zu überprüfen, ob ein bestimmter Wert in einer internen Tabelle enthalten ist oder nicht, kann die eingebaute Tabellenfunktion LINE_EXISTS verwendet werden.

    DATA lt_values  TYPE SORTED TABLE OF zdemo_value WITH UNIQUE KEY id.

lt_values = VALUE #( ( id = 1 value = 'Test1' )
                     ( id = 2 value = 'Test2' )
                     ( id = 3 value = 'Test3' )
                     ( id = 4 value = 'Test4' )
                     ( id = 5 value = 'Test5' )
                     ( id = 6 value = 'Test6' ) ).

IF line_exists( lt_values[ id = 6 ] ).
  DATA(lv_value) = lt_values[ id = 6 ]-value.
  cl_demo_output=>display( lv_value ).
ELSE.
  cl_demo_output=>display( 'Line not found' ).
ENDIF.

    LINES

    AB ABAP 7.40

    Die Funktion LINES() ermittelt die Zeilenanzahl einer Tabelle und ähnelt damit DESCRIBE TABLE. Im Gegensatz dazu ermöglicht LINES() eine direkte Verwendung an der Operandenposition und erspart eine zusätzliche Codezeile.

    DATA lt_values  TYPE SORTED TABLE OF zdemo_value WITH UNIQUE KEY id.

lt_values = VALUE #( ( id = 1 value = 'Test1' )
                     ( id = 2 value = 'Test2' )
                     ( id = 3 value = 'Test3' )
                     ( id = 4 value = 'Test4' )
                     ( id = 5 value = 'Test5' )
                     ( id = 6 value = 'Test6' ) ).

DATA(lv_lines) = lines( lt_values ).

    Über den Autor

    Andreas Geiger

    Mein Name ist Andreas Geiger und ich bin ein erfahrener Senior SAP Berater. Mit mehr als 10 Jahren Berufserfahrung habe ich mehrere SAP-Projekte erfolgreich abgeschlossen und umfangreiche Kenntnisse in verschiedenen Bereichen wie SAP FI, SAP MM und ABAP erworben. Nun möchte ich mein Wissen mit Dir teilen, um Dir einen Mehrwert zu bieten und Dich bei Deiner täglichen Arbeit mit dem SAP-System zu unterstützen.

    Mehr zu ERP UP

    ERP UP unterstützen

    Wenn Du mit ERP UP zufrieden bist, kannst Du mich gerne unterstützen. Dabei gibt es unzählige Möglichkeiten, wie Du mich einfach und schnell unterstützen kannst. Wie Du genau ERP UP unterstützen kannst, erfährst Du hier. Vielen Dank.

    Schreibe einen Kommentar