In diesem Artikel gebe ich Dir einen umfassenden Überblick über die wichtigsten Konstruktorausdrücke bzw. Konstruktoroperatoren in ABAP 7.40. Anhand vieler praktischer Beispiele werde ich Dir die Funktionen und die Syntax der Operatoren verständlich erklären und Dir zeigen, wie Du sie erfolgreich in Deinen eigenen ABAP-Programmen einsetzen kannst. Zusätzlich werde ich Dir bei einigen Operatoren auch die frühere Alternative zeigen, um Dir einen noch besseren Überblick zu verschaffen. Durch den optimalen Einsatz der Konstruktor-Operationen in Deinen Projekten wirst Du nicht nur effizientere, sondern auch robustere Anwendungen entwickeln können. Lass uns gemeinsam in die Welt der ABAP-Operatoren eintauchen.
NEW
Der Operator NEW wird verwendet, um eine Instanz einer Klasse zu erzeugen.
*---------------------------------------------------------------------* * Ohne NEW - Alt *---------------------------------------------------------------------* DATA: lo_object TYPE REF TO lcl_class. CREATE OBJECT lo_object. *---------------------------------------------------------------------* * Mit NEW - Neu *---------------------------------------------------------------------* DATA(lo_object) = NEW lcl_class( ).
Wenn die Klasse einen Konstruktor mit Parametern hat, kannst Du die Parameter in runden Klammern ( ) übergeben.
*---------------------------------------------------------------------*
* Mit NEW - Neu
* Parameterübergabe
*---------------------------------------------------------------------*
DATA(lo_object) = NEW lcl_class( im_name = 'Andreas Geiger'
im_job = 'Senior SAP Consultant' ).
VALUE
Der Operator VALUE ist eines der nützlichsten zusätzlichen ABAP-Schlüsselwörter ab ABAP 7.40. Mit diesem Schlüsselwort kannst Du alle Arten von Daten erzeugen, wie in den folgenden Beispielen gezeigt wird.
TYPES: BEGIN OF ty_user,
id TYPE i,
name TYPE char50,
END OF ty_user,
tt_user TYPE STANDARD TABLE OF ty_user WITH EMPTY KEY.
*---------------------------------------------------------------------*
* Struktur
*---------------------------------------------------------------------*
DATA(ls_user) = VALUE ty_user( id = 1
name = 'Max Mustermann' ).
*---------------------------------------------------------------------*
* Interne Tabelle
*---------------------------------------------------------------------*
DATA(lt_itab) = VALUE tt_user(
( id = 2 name = 'Peter Müller' )
( id = 3 name = 'Max Wilfert' )
( id = 4 name = 'Torben Hegen' )
).
*---------------------------------------------------------------------*
* Verschachtelte Struktur
*---------------------------------------------------------------------*
TYPES: BEGIN OF ty_ceo,
id TYPE i,
name TYPE char50,
alter TYPE i,
END OF ty_ceo,
BEGIN OF ty_company,
name TYPE text40,
ceo TYPE ty_ceo,
END OF ty_company.
DATA(ls_company) = VALUE ty_company(
name = 'Unternehmen A GmbH'
ceo = VALUE #(
id = 1
name = 'Max Mustermann'
alter = 35
)
).
*---------------------------------------------------------------------*
* Bereich
*---------------------------------------------------------------------*
DATA lt_bereich TYPE RANGE OF i.
lt_bereich = VALUE #(
sign = 'I' option = 'EQ'
( low = 1 )
( low = 5 )
( low = 15 )
).
Das #-Zeichen wird nach dem Schlüsselwort VALUE zusammen mit der Inline-Datendeklaration verwendet. Dies bedeutet, dass der Typ der Variablen oder Felder implizit oder aus der vorhergehenden Deklaration bestimmt wird. Soll ein bestimmter Typ verwendet werden, so ist dieser anstelle von # anzugeben.
Da in der Bereichskonstruktion „sign = ‚I'“ und „option = ‚EQ'“ für alle Einträge gleich sind, werden sie nur einmal oben außerhalb der inneren ( ) angegeben.
CORRESPONDING
Mit der Anweisung CORRESPONDING kann der Inhalt einer Tabelle in eine andere Tabelle verschoben werden, wenn die Tabellentypen nicht genau gleich sind. Diese Anweisung kann auch für Strukturen verwendet werden.
TYPES: BEGIN OF ty_a,
a1 TYPE i,
a2 TYPE i,
a3 TYPE char10,
END OF ty_a,
BEGIN OF ty_b,
a1 TYPE i,
a2 TYPE i,
b1 TYPE char50,
END OF ty_b.
DATA: ls_a TYPE ty_a,
ls_b TYPE ty_b,
lt_tabelle TYPE STANDARD TABLE OF ty_a,
lt_mapping TYPE STANDARD TABLE OF ty_b,
lt_duplikat TYPE STANDARD TABLE OF ty_a WITH UNIQUE SORTED KEY key1 COMPONENTS a1.
lt_tabelle = VALUE #( ( a1 = 1 a2 = 10 a3 = 'TEST A' )
( a1 = 2 a2 = 20 a3 = 'TEST B' )
( a1 = 3 a2 = 30 a3 = 'TEST C' )
( a1 = 3 a2 = 40 a3 = 'TEST C' ) ).
*---------------------------------------------------------------------*
* Struktur
*---------------------------------------------------------------------*
READ TABLE lt_tabelle INTO ls_a INDEX 1.
ls_b = CORRESPONDING #( ls_a ).
*---------------------------------------------------------------------*
* Interne Tabelle
*---------------------------------------------------------------------*
lt_mapping = CORRESPONDING #( lt_tabelle ).
*---------------------------------------------------------------------*
* Interne Tabelle mit Mapping
*---------------------------------------------------------------------*
lt_mapping = CORRESPONDING #( lt_tabelle MAPPING a2 = a1 a1 = a2 b1 = a3 ).
*---------------------------------------------------------------------*
* Duplikate entfernen
*---------------------------------------------------------------------*
lt_duplikat = CORRESPONDING #( lt_tabelle DISCARDING DUPLICATES ).
FILTER
Mit dem Operator FILTER kannst Du nach Einträgen in internen Tabellen filtern. Du kannst die Zeilen verschieben, die der WHERE-Bedingung entsprechen, oder Du kannst EXCEPT verwenden und die Zeilen verschieben, die der WHERE-Bedingung nicht entsprechen.
DATA lt_tcodes TYPE SORTED TABLE OF tstct WITH NON-UNIQUE KEY sprsl. *---------------------------------------------------------------------* * Hinweis: Natürlich ist es performanter und besser direkt beim * SELECT nach der Sprache zu filtern. Das ist ein Beispiel. *---------------------------------------------------------------------* SELECT * FROM tstct WHERE tcode LIKE 'Z%' ORDER BY ttext INTO TABLE @lt_tcodes. *---------------------------------------------------------------------* * Alle Z-Transaktionen in Deutsch *---------------------------------------------------------------------* DATA(lt_tcode_de) = FILTER #( lt_tcodes WHERE sprsl = 'D' ). *---------------------------------------------------------------------* * Alle Z-Transaktionen nicht in Deutsch *---------------------------------------------------------------------* DATA(lt_tcode_not_de) = FILTER #( lt_tcodes EXCEPT WHERE sprsl = 'D' ).
COND
Der Operator COND wertet eine hinter WHEN angegebene Bedingung aus und weist den hinter THEN angegebenen Wert zu. Sind alle Bedingungen falsch, wird der hinter ELSE angegebene Wert zugewiesen.
*---------------------------------------------------------------------*
* COND
*---------------------------------------------------------------------*
DATA(lv_result) = COND #( WHEN sy-msgty = 'S' THEN 'Erfolg'
WHEN sy-msgty = 'W' THEN 'Warnung'
WHEN sy-msgty = 'I' THEN 'Information'
WHEN sy-msgty = 'A' THEN 'Abbruch'
ELSE 'Undefinierter Fehler' ).
SWITCH
Der Operator SWITCH ist ähnlich wie COND, verwendet aber eine einzelne Variable und funktioniert ähnlich wie eine CASE-Anweisung im herkömmlichen ABAP.
*---------------------------------------------------------------------*
* SWITCH
*---------------------------------------------------------------------*
DATA(lv_result) = SWITCH #( sy-msgty
WHEN 'S' THEN 'Erfolg'
WHEN 'W' THEN 'Warnung'
WHEN 'I' THEN 'Information'
WHEN 'A' THEN 'Abbruch'
ELSE 'Undefinierter Fehler' ).
Mit COND # kann man komplexere Bedingungen schreiben als mit SWITCH, aber wenn man nur eine Variable hat, ist SWITCH schneller zu schreiben und zu verstehen.
CONV
Mit dem Operator CONV entfällt die Notwendigkeit, Hilfsvariablen bei der Datenübergabe an Methodenparameter zu verwenden oder den Wert eines Feldes eines Typs zu ändern und in ein Feld eines anderen Typs zu übertragen.
DATA : lv_text TYPE c LENGTH 255,
lv_text_tmp TYPE string,
lv_xstr TYPE xstring.
*---------------------------------------------------------------------*
* Alt - Konvertierung durch Zuweisung
*---------------------------------------------------------------------*
lv_text_tmp = lv_text.
lv_xstr = cl_abap_codepage=>convert_to( source = lv_text_tmp ).
*---------------------------------------------------------------------*
* Neu - Konvertierung durch CONV
*---------------------------------------------------------------------*
DATA lv_text2 TYPE char255.
DATA(lv_xstr2) = cl_abap_codepage=>convert_to( source = CONV #( lv_text2 ) ).
REF
Der Operator REF wird verwendet, um die Referenz der Daten zu erhalten.
*---------------------------------------------------------------------*
* Alt - GET REFERENCE
*---------------------------------------------------------------------*
TYPES tt_po TYPE STANDARD TABLE OF ekko WITH EMPTY KEY.
DATA: lt_po TYPE tt_po,
lr_po TYPE REF TO tt_po.
SELECT * FROM ekko INTO TABLE lt_po.
GET REFERENCE OF lt_po INTO lr_po.
*---------------------------------------------------------------------*
* Neu - REF
*---------------------------------------------------------------------*
SELECT * FROM ekko INTO TABLE @DATA(lt_po2).
DATA(lr_po2) = REF #( lt_po2 ).
REDUCE
Der Operator REDUCE erzeugt ein Ergebnis eines bestimmten Typs durch eine oder mehrere Iterationen (Schleife). Ein einfaches Beispiel ist die Addition der Zahlen von 1 bis 100.
*---------------------------------------------------------------------*
* 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 ).
EXACT
Der Operator EXACT kann verwendet werden, um der Ergebnisvariablen eine Variable oder einen Ausdruck zuzuweisen. Die verwendeten Variablentypen sind in der Regel unterschiedlich. Wenn die Zuweisung nicht verlustfrei durchgeführt werden kann, d.h. wenn die Daten nicht konvertiert werden können, werden Ausnahmen ausgelöst. Zum Beispiel.
*---------------------------------------------------------------------*
* Konvertierungsfehler
*---------------------------------------------------------------------*
TYPES ty_numtxt TYPE n LENGTH 255.
TRY.
DATA(lv_num) = EXACT ty_numtxt( '3 Autos + 4 Personen' ).
CATCH cx_sy_conversion_error INTO DATA(ex_num).
MESSAGE 'Ausnahme CX_SY_CONVERSION_ERROR ist aufgetreten.' TYPE 'E'.
ENDTRY.
*---------------------------------------------------------------------*
* Rundungsfehler
*---------------------------------------------------------------------*
TRY.
DATA(lv_exact_result) = EXACT #( 3 * ( 1 / 3 ) ).
CATCH cx_sy_conversion_rounding INTO DATA(ex_num2).
DATA(lv_result_rounded) = ex_num2->value.
ENDTRY.
Über den Autor
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.
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.
