Moderne ABAP New Syntax (ABAP 7.40+)

Ein Handbuch zu Inline-Deklarationen, Tabellenausdrücken, performanten Datenverarbeitungsoperatoren und funktionalen Schleifenarchitekturen, die mit dem ABAP der neuen Generation (7.40 und höher) eingeführt wurden.

Modernes ABAP verändert die klassischen Datenverarbeitungsmethoden grundlegend und ermöglicht es uns, Entwicklungen mit weniger Codezeilen, besserer Lesbarkeit und Speicheroptimierung (HANA-fokussiert) durchzuführen. In diesem Leitfaden finden Sie die am häufigsten benötigten modernen Syntaxstrukturen, von Datenzuweisungen bis hin zu fortgeschrittenen Gruppenschleifen, an einem Ort.

💡 Moderne Architekturansätze & Regeln

Performance von Inline-Deklarationen: Spontane Definitionen mit DATA(...) oder FIELD-SYMBOL(...) erhöhen die Entwicklungsgeschwindigkeit. Es sollte jedoch darauf geachtet werden, nicht kontinuierlich dieselbe Objektstruktur innerhalb einer Schleife (LOOP) inline zu erzeugen und die unnötige Verwendung von CONV zu vermeiden, wenn der Typ bereits bekannt ist.
Schleifenoptimierung: Während INTO DATA(...) die Daten in jeder Iteration in den Speicher kopiert, zeigt ASSIGNING FIELD-SYMBOL(...) direkt auf die Speicheradresse (Datenzeiger). Für eine bessere Performance bei Lese- und Überschreibvorgängen sollten Feldsymbole bevorzugt werden, während für Objektmanipulationen die Architektur REFERENCE INTO (Datenreferenz) empfohlen wird.
Risiken der funktionalen Programmierung: Obwohl Ausdrücke wie REDUCE, FILTER und FOR den Code-Umfang reduzieren, können sie das Debugging bei komplexer Implementierung auf sehr großen Datensätzen erschweren. Sie sollten sauber und modular strukturiert sein.

💻 Referenz zur modernen ABAP-Syntax

0. LOOP AT-Varianten (Field Symbol, Into Data, Reference Into & Grouping)

Speicherverwaltungsansätze in internen Tabellenschleifen und die leistungsstarke LOOP AT ... GROUP BY-Architektur, die mit ABAP 7.40 eingeführt wurde.

* 1. Assigning Field Symbol (High performance pointer mapping)
LOOP AT gt_data ASSIGNING FIELD-SYMBOL(<ls_row>).
  <ls_row>-status = 'S'.
ENDLOOP.

* 2. Into Data (Row copying mechanism into memory)
LOOP AT gt_data INTO DATA(ls_row).
  " Keep the current line index
  DATA(lv_index) = sy-tabix.

  " Modify the fields in the local work area
  ls_row-status = 'C'. " Completed
  ls_row-updated_at = sy-uzeit.

  " Apply the changes back to the internal table using the index
  MODIFY gt_data FROM ls_row INDEX lv_index.
ENDLOOP.

* 3. Reference Into (Data reference instantiation, ideal for object-oriented design)
LOOP AT gt_data REFERENCE INTO DATA(lr_row).
  lr_row->status = 'P'.
ENDLOOP.

* 4. LOOP AT GROUP BY (Modern and type-safe replacement for AT NEW)
LOOP AT gt_data INTO DATA(ls_line)
  GROUP BY ( customer = ls_line-kunnr land = ls_line-land1 )
  ASSIGNING FIELD-SYMBOL(<fs_group>).
ENDLOOP.
  " Accessing group keys directly
  WRITE: / <fs_group>-customer, <fs_group>-land.

" Direct modification of the internal table using a Field Symbol
LOOP AT gt_data ASSIGNING FIELD-SYMBOL(<fs_row>).
  " Apply the desired changes directly to the memory area
  <fs_row>-status = 'X'.
  <fs_row>-descr  = 'Updated'.
ENDLOOP.

1. VALUE #-Operator (Zeilen/Tabellen füllen & Append VALUE)

Dies ist ein Operator zum spontanen Füllen einer Struktur oder einer internen Tabelle, indem der Variablentyp aus der Zielstruktur abgeleitet wird (Typinferenz). Er eliminiert die klassische Abfolge von CLEAR und APPEND.

" Structuring data directly

types : begin of ty_customer,
          kunnr type kna1-kunnr,
          name1 type kna1-name1,
        end of ty_customer.

DATA(ls_customer) = VALUE ty_customer( kunnr = '1000' name1 = 'Ahmet' ).

" Populating multiple lines to an internal table using type inference (#)
DATA lt_list TYPE STANDARD TABLE OF ty_customer.
lt_list = VALUE #( ( kunnr = '1001' name1 = 'Mehmet' )
                   ( kunnr = '1002' name1 = 'Can' ) ).

" Append VALUE syntax equivalent
APPEND VALUE #( kunnr = '1003' name1 = 'Asli' ) TO lt_list.

2. CORRESPONDING (Felder mit gleichem Namen zuordnen)

Dies ist die funktionale und direkt zuweisbare Version des klassischen MOVE-CORRESPONDING-Befehls. Sie verschiebt nicht nur Spalten mit übereinstimmenden Namen, sondern kann auch bestimmte Spalten ausschließen (EXCEPT) oder Felder mit unterschiedlichen technischen Namen zuordnen (MAPPING).

REPORT z_development01.

" Sample structure definitions for demonstration
TYPES: BEGIN OF ty_source,
         id            TYPE i,
         name          TYPE string,
         status        TYPE char1,
         creation_date TYPE dats,
         source_uuid   TYPE sysuuid_c32,
       END OF ty_source.

TYPES: BEGIN OF ty_target,
         id            TYPE i,
         name          TYPE string,
         status        TYPE char1,
         creation_date TYPE dats,
         target_id     TYPE sysuuid_c32,
       END OF ty_target.

DATA(ls_source) = VALUE ty_source( id            = 1
                                   name          = 'Source Data'
                                   status        = 'A'
                                   creation_date = sy-datum
                                   source_uuid   = '0123456789ABCDEF' ).
DATA ls_target TYPE ty_target.

" ----------------------------------------------------
" 1. Standard structure mapping
" ----------------------------------------------------
ls_target = CORRESPONDING #( ls_source ).

" ----------------------------------------------------
" 2. Advanced mapping with exclusion (Excepting specific fields)
" ----------------------------------------------------
ls_target = CORRESPONDING #( ls_source EXCEPT status creation_date ).

" ----------------------------------------------------
" 3. Mapping fields with different technical names
" ----------------------------------------------------
" Syntactical order: TARGET_FIELD = SOURCE_FIELD
ls_target = CORRESPONDING #( ls_source MAPPING target_id = source_uuid ).

3. Verwendung von BASE (Hinzufügen unter Beibehaltung vorhandener Daten)

Die Operatoren VALUE oder CORRESPONDING leeren naturgemäß zuerst die Zielstruktur. Der Ausdruck BASE teilt dem System die vorhandene Matrix/Tabelle mit, die als Basis verwendet werden soll, um das Löschen alter Daten in der Zieltabelle oder -struktur zu verhindern.

REPORT z_development01.
" ----------------------------------------------------
" Data Definitions
" ----------------------------------------------------
TYPES: BEGIN OF ty_customer,
         kunnr TYPE kna1-kunnr,
         name1 TYPE kna1-name1,
       END OF ty_customer,
       tt_customer TYPE STANDARD TABLE OF ty_customer WITH EMPTY KEY.

TYPES: BEGIN OF ty_target,
         id            TYPE i,
         name          TYPE string,
         status        TYPE char1,
         creation_date TYPE dats,
       END OF ty_target.

TYPES: BEGIN OF ty_source,
         id   TYPE i,
         name TYPE string,
       END OF ty_source.

" ----------------------------------------------------
" 1. Internal Table Example: Retaining existing rows with VALUE & BASE
" ----------------------------------------------------
DATA lt_list TYPE tt_customer.

" Initial data populating
lt_list = VALUE #( ( kunnr = '1001' name1 = 'Mehmet' )
                   ( kunnr = '1002' name1 = 'Can' ) ).

" Adding a new line without overwriting the existing content of lt_list
lt_list = VALUE #( BASE lt_list
                   ( kunnr = '1004' name1 = 'Deniz' ) ).

" ----------------------------------------------------
" 2. Structure Example: Keeping destination fields intact with CORRESPONDING & BASE
" ----------------------------------------------------
DATA ls_target TYPE ty_target.
DATA ls_source TYPE ty_source.

" Pre-populating target structure with some fields that do NOT exist in the source structure
ls_target = VALUE ty_target( id            = 99
                             name          = 'Old Name'
                             status        = 'X'               " This field will be preserved
                             creation_date = '20260707' ).     " This field will be preserved

" New source data to be mapped
ls_source = VALUE ty_source( id   = 100
                             name = 'New Name From Source' ).

" Mapping with BASE prevents status and creation_date from being wiped out
ls_target = CORRESPONDING #( BASE ( ls_target ) ls_source ).

4. Bedingte Ausdrücke COND & SWITCH

Sie ermöglichen Zuweisungen durch die Erstellung von inline logischen Abfragen. Sie machen komplexe IF-ELSE-Blöcke mit COND funktional und sauber und behandeln den Wertabgleich für eine einzelne Variable (CASE-WHEN) mit SWITCH.

REPORT z_development01.

DATA lv_status TYPE char1.
DATA lv_blart  TYPE blart.

" COND: Complex logical evaluations (IF-ELSE equivalent)
DATA(lv_status_text) = COND string( WHEN lv_status = 'A' THEN 'Approved'
                                    WHEN lv_status = 'R' THEN 'Rejected'
                                    ELSE                      'Pending' ).

" SWITCH: Direct value matching (CASE-WHEN equivalent)
DATA(lv_doc_type) = SWITCH string( lv_blart
                                   WHEN 'SA' THEN 'G/L Account Document'
                                   WHEN 'KR' THEN 'Vendor Invoice'
                                   ELSE           'Unknown Document' ).

5. Definition lokaler Variablen mit LET

Es erstellt temporäre lokale Hilfsvariablen innerhalb eines Ausdrucks, einer Schleife oder einer Inline-Berechnung, die nur zum Zeitpunkt der Zuweisung gültig sind und nach Abschluss der Funktion automatisch aus dem Speicher gelöscht werden. Es verhindert die Verschmutzung durch globale Hilfsvariablen.

DATA(lv_formatted_date) = CONV string( LET lv_year  = sy-datum(4)
                                            lv_month = sy-datum+4(2)
                                            lv_day   = sy-datum+6(2)
                                        IN |{ lv_day }.{ lv_month }.{ lv_year }| ).

6. FOR & FOR GROUPS (Inline-Schleifen)

Es ahmt die Logik des klassischen LOOP AT auf inline-Weise nach. Es ermöglicht die schnelle Manipulation oder Filterung (WHERE) von Daten in einer Tabelle, um eine andere Tabelle in einer einzigen Zeile zu füllen oder Gruppenhierarchien zu erstellen.

REPORT z_development01.
" ----------------------------------------------------
" Data Definitions
" ----------------------------------------------------
TYPES: BEGIN OF ty_source,
         kunnr TYPE kna1-kunnr,
         name1 TYPE kna1-name1,
         land1 TYPE kna1-land1,
       END OF ty_source,
       tt_source TYPE STANDARD TABLE OF ty_source WITH EMPTY KEY.

TYPES: BEGIN OF ty_target,
         customer_id TYPE kna1-kunnr,
       END OF ty_target,
       tt_target TYPE STANDARD TABLE OF ty_target WITH EMPTY KEY.

TYPES: BEGIN OF ty_summary,
         customer TYPE kna1-kunnr,
       END OF ty_summary,
       tt_summary TYPE STANDARD TABLE OF ty_summary WITH EMPTY KEY.

" Preparing sample source data
DATA(lt_source_list) = VALUE tt_source( ( kunnr = '1001' name1 = 'Ahmet'  land1 = 'TR' )
                                        ( kunnr = '1002' land1 = 'DE' ) " Will be filtered out
                                        ( kunnr = '1003' name1 = 'Mehmet' land1 = 'TR' ) ).

" ----------------------------------------------------
" 1. FOR: Inline Loop Simulation with WHERE Clause
" ----------------------------------------------------
" Evaluates the source table lines and populates the target table on the fly
DATA(lt_target_list) = VALUE tt_target( FOR ls_source_line IN lt_source_list
                                        WHERE ( land1 = 'TR' )
                                        ( customer_id = ls_source_line-kunnr ) ).

" ----------------------------------------------------
" 2. FOR GROUPS: Advanced Grouping (Loop At ... Group By equivalent)
" ----------------------------------------------------
" Groups the internal table lines by kunnr and returns unique group keys
DATA(lt_grouped) = VALUE tt_summary( FOR GROUPS group_key OF ls_line IN lt_source_list
                                     GROUP BY ls_line-kunnr
                                     ( customer = group_key ) ).

7. REDUCE (Datenreduktion / Aggregation)

Es führt eine vertikale Datenreduktion über eine interne Tabellenschleife durch. Es wird verwendet, um durch Iteration durch die Tabelle einen einzigen kumulativen Wert zu erzeugen (z. B. Gesamtbetrag, ein durch Kommas getrennter String oder ein mathematisches Ergebnis). Mit `INIT` wird ein Zähler/Anfangswert bereitgestellt.

" Summarizing internal table values into a single variable
DATA(lv_total_net_worth) = REDUCE netwr( INIT lv_sum = 0 
                                         FOR ls_item IN lt_invoice_items
                                         NEXT lv_sum = lv_sum + ls_item-netwr ).

8. FILTER (Filterung auf Tabellenebene)

Es filtert eine interne Tabelle direkt auf Kernelebene basierend auf bestimmten Kriterien und überträgt sie in eine neue Tabelle, ohne eine Schleife (LOOP) auf der Anwendungsebene zu verwenden. Um einen Leistungsvorteil zu erzielen, muss die zu filternde Tabelle als SORTED- oder HASHED-Tabellentyp konzipiert sein.

" Filtering table rows based on explicit single condition value
DATA(lt_tr_customers) = FILTER #( lt_all_customers WHERE land1 = 'TR' ).

" Filter using an exclusionary logic (EXCEPT)
DATA(lt_foreign_customers) = FILTER #( lt_all_customers EXCEPT WHERE land1 = 'TR' ).

9. Tabellenausdrücke & Zeilenprüfungen

Dies sind Inline-Leseindizes, die den klassischen, umständlichen READ TABLE-Befehl vollständig ersetzen. Der direkte Zugriff erfolgt über eckige Klammern `[]`. Um einen Dump zu verhindern, wenn der gesuchte Wert nicht gefunden wird, sollte er mit den Schlüsselwörtern OPTIONAL oder DEFAULT unterstützt werden.

" Reading row directly into a structure (Fails with dump if index not found)
DATA(ls_row) = lt_data[ 1 ].

" Reading row via specific business key values safely (OPTIONAL prevents dumps)
DATA(ls_sale) = VALUE #( lt_sales[ vbeln = '0090000001' ] OPTIONAL ).

" Line existence validation check (Alternative syntax for line_exists() - Returns Boolean)
IF line_exists( lt_sales[ vbeln = '0090000001' ] ).
  " Key exists, safely execute logic
ENDIF.

10. CONV, EXACT & XSDBOOL

Dies sind Werkzeuge zur Typkonvertierung und logischen Simulation. CONV führt eine dynamische Typkonvertierung durch, während EXACT bei Datenverlust-/Präzisionsrisiken einen Fehler auslöst. XSDBOOL ermöglicht die Zuweisung eines logischen booleschen Typs (X oder Leerzeichen), der in ABAP nicht nativ existiert, zu Ausdrücken.

" CONV: Dynamic runtime data type conversion
CALL METHOD lo_service->execute_task( iv_input = CONV string( lv_raw_data ) ).

" EXACT: Type conversion ensuring no data/type precision loss occurs
DATA(lv_exact_num) = EXACT i( lv_string_numeric ).

" XSDBOOL: Converts logical expressions into actual abap_bool type variables (X/space)
DATA(lv_is_valid) = xsdbool( lv_amount > 1000 AND lv_currency = 'EUR' ).

11. Objektoperatoren NEW, REF und CAST

Sie reduzieren den Aufwand für die Instanzerstellung in der objektorientierten Programmierung (OOP). NEW erstellt direkt ein Objekt (anstelle von CREATE OBJECT), REF holt einen dynamischen Datenreferenzzeiger (anstelle von GET REFERENCE) und CAST reduziert Laufzeit-Typkonvertierungen (Down-cast / Up-cast) auf eine einzige Zeile.

" NEW: Inline instantiation of object classes (Replaces CREATE OBJECT)
DATA(lo_processor) = NEW zcl_data_processor( ).

" REF: Generates data reference pointer dynamically (Replaces GET REFERENCE)
DATA(lr_sales_data) = REF #( lt_sales ).

" CAST: Runtime object casting interface conversion
DATA(lo_alv_table) = CAST cl_salv_table( lo_generic_instance ).

Verpassen Sie nicht den neuen Code in der Bibliothek!

Abonnieren Sie den Newsletter, um sofort über wöchentlich aktualisierte unternehmensweite ABAP-Komponenten, Leistungstipps und Architekturentwürfe informiert zu werden.