ABAP - XCO Strings
In diesem Artikel schauen wir uns die XCO Klasse zur Erzeugung und Verarbeitung von Strings für ABAP Cloud an und vergleichen sie mit den klassischen Statements.
Inhaltsverzeichnis
Die XCO Klassen sind Hilfsklassen die verschiedene Funktionen des Alltags gebündelt unter einer öffentlichen API zur Verfügung stellen. Weitere Informationen und eine Übersicht über die XCO Bibliotheken findest du auf der Übersichtsseite.
Einleitung
In diesem Artikel schauen wir uns die Sammlung der String Funktionen an und wie du sie nutzen kannst. Dazu gibt es verschiedene String Objekte, die du aus der Basis XCO_CP erhalten kannst. In den folgenden Abschnitten gehen wir auf die verschiedenen Objekte ein und schauen uns die Unterschiede zu Klassisch, Modern und XCO an.
STRING
Über XCO_CP=>STRING erhalten wir ein String Objekt, mit dem wir einen einzelnen String verarbeiten können. Im Interface IF_XCO_STRING findest du die entsprechenden Methoden für die Verwendung und in der Klasse CL_XCO_STRING die Implementierung.
Lower/Upper
Für die Konvertierung Richtung Lower und Upper Case eines Strings, gibt es jeweils ähnliche Methoden in allen drei Versionen. Dazu ein Beispiel für die Großkonvertierung.
" Classic
TRANSLATE ld_string TO UPPER CASE.
" Modern
ld_string = to_upper( c_string ).
" XCO
ld_string = xco_cp=>string( c_string )->to_upper_case( )->value.
Substring
Die Ermittlung eines Teilstrings aus einem Text wir normalerweise Substring genannt. Dazu stehen dir unterschiedliche Befehle und Methoden in ABAP zur Verfügung.
" Classic
ld_string = c_string+11(3).
" Modern
ld_string = substring( val = c_string off = 11 len = 3 ).
" XCO
ld_string = xco_cp=>string( c_string )->from( 12 )->to( 3 )->value.
Wie dir sicherlich aufgefallen ist, arbeitet die XCO Klasse hier etwas anders. Mit FROM extrahieren wir den Substring von unserer Zeichenkette ab dem 12 Zeichen bis zum Ende. Im nächsten Schritt extrahieren wir den neuen Teilstring bis zum dritten Zeichen.
Split
Du möchtest einen String an einem Trennzeichen teilen und dabei eine flexible Menge an neuen Strings erhalten? Dafür wird der SPLIT Befehl in ABAP verwendet. Dieser besitzt keine moderne Version, sondern nur die klassische Version.
" Classic
SPLIT c_string AT c_seperator INTO TABLE DATA(lt_parts).
" Modern
" XCO
lt_parts = xco_cp=>string( c_string )->split( c_seperator )->value.
Anhängen
Um etwas an den Anfang (PREPEND) oder am Ende (APPEND) eines Strings anzuhängen, gibt es verschiedene Varianten in ABAP.
" Classic
CONCATENATE c_string c_part INTO ld_string.
" Modern
ld_string = c_string && c_part.
" XCO
ld_string = xco_cp=>string( c_string )->append( c_part )->value.
Teil prüfen
Du möchtest den Anfang (STARTS_WITH) oder das Ende (ENDS_WITH) eines Strings überprüfen gegen eine Zeichenkette, da musst du in den meisten Fällen schon etwas mehr Code implementieren. Hier lohnt sich ein Blick auf die Methoden der XCO Klasse.
" Classic
DATA(ld_start) = strlen( c_string ) - strlen( c_point ) - 1.
DATA(ld_length) = strlen( c_point ).
IF c_string+ld_start(ld_length) = c_point.
ENDIF.
" Modern
IF substring( val = c_string
off = strlen( c_string ) - strlen( c_point ) - 1
len = strlen( c_point ) ) = c_point.
ENDIF.
" XCO
IF xco_cp=>string( c_string )->ends_with( c_point ).
ENDIF.
Regulärer Ausdruck
Für die Verwendung von regulären Ausdrücken gibt es zwei Methoden. Mit der Methode MATCHES kannst du deinen String gegen einen regulären Ausdruck abgleichen. Mit der Methode GREP, kannst du dir alle Teile zurückgeben lassen, die dem Suchpattern entsprechen.
" Classic
FIND ALL OCCURRENCES OF PCRE c_regex IN c_string RESULTS DATA(lt_found).
LOOP AT lt_found INTO DATA(ls_found).
INSERT c_string+ls_found-offset(ls_found-length) INTO TABLE lt_parts.
ENDLOOP.
CLEAR lt_parts.
" Modern
ld_start = 0.
DO.
DATA(ld_position) = find( val = c_string
pcre = c_regex
off = ld_start ).
IF ld_position = -1.
EXIT.
ENDIF.
DATA(ld_to) = find_end( val = c_string
pcre = c_regex
off = ld_start ).
INSERT substring( val = c_string
off = ld_position
len = ld_to - ld_position ) INTO TABLE lt_parts.
ld_start = ld_to.
ENDDO.
" XCO
lt_parts = xco_cp=>string( c_string )->grep( iv_regular_expression = c_regex
io_engine = xco_cp_regular_expression=>engine->pcre( )
)->value.
Hinweis: Aktuell scheint GREP nicht mit dem gleichen regulären Ausdruck zu funktionieren, hier sind wir aktuell in Abstimmung.
Zerlegen
Für den speziellen Ausdruck der Methode DECOMPOSE möchten wir nur die Verwendung aufführen, da das Auflösen des Strings anhand der Groß- und Kleinschreibung einiges an Logik benötigt. Der Methode kannst du noch verschiedene Verfahren mitgeben (PascalCase und camelCase). Nach der Zerlegung erhalten wir eine Tabelle mit vier Einträgen.
lt_parts = xco_cp=>string( `MyNameIsPascal` )->decompose( xco_cp_string=>decomposition->pascal_case )->value.
Das Gegenstück findest du in der STRINGS Klasse mit der Methode COMPOSE, um dann die einzelnen Bestandteile wieder nach Logik zu verknüpfen.
Konvertieren
Bei der Konvertierung von String nach XString gibt es aktuell verschiedene Funktionsbausteine, Klassen und andere Möglichkeiten. Mit der Methode AS_XSTRING erhältst du die Möglichkeit, den String mit der richtigen Codepage zu konvertieren.
" Classic
CALL FUNCTION 'SCMS_STRING_TO_XSTRING'
EXPORTING
text = c_string
IMPORTING
buffer = ld_xstring
EXCEPTIONS
failed = 1
OTHERS = 2.
IF sy-subrc <> 0.
ENDIF.
" Modern
ld_xstring = cl_abap_codepage=>convert_to( source = c_string ).
" XCO
ld_xstring = xco_cp=>string( c_string )->as_xstring( xco_cp_character=>code_page->utf_8 )->value.
Meldung
Möchtest du einen String als Meldung ausgeben, musst du ein entsprechendes Mapping vornehmen, um die Nachrichtenfelder zu befüllen. Mit der Methode AS_MESSAGE, kannst du aus dem Text ein Nachrichtenklasse erzeugen und diese weiterverwenden. So kannst du dir die Nachricht als Struktur SYMSG zurückgeben lassen. Dazu musst du nur auf VALUE des Objekts zurückgreifen.
DATA(ls_message) = xco_cp=>string( c_long_string )->as_message( xco_cp_message=>type->error )->value.
Schauen wir uns dann die Struktur von LS_MESSAGE an, erhalten wir den richtigen Typ für die Meldung, eine Meldungsklasse mit Platzhaltern und das Mapping des Strings.
Als zweites Beispiel können wir auch eine Ausnahmeklasse erzeugen und die Meldung in der Klasse überschreiben lassen.
DATA(lo_message) = NEW cx_abap_context_info_error( ).
xco_cp=>string( c_long_string )->as_message( )->write_to_t100_dyn_msg( lo_message ).
Das Ergebnis können wir uns nun im "ABAP Exception (Debugger)" View anschauen und validieren.
STRINGS
Über XCO_CP=>STRINGS erhalten wir ein String Objekt, mit dem wir eine Tabelle von Strings bearbeiten können. Verwenden wir in der String Klasse die SPLIT Methode, erhalten wir zum Beispiel so ein Objekt. Im Interface IF_XCO_STRINGS findest du die entsprechenden Methoden für die Verwendung und in der Klasse CL_XCO_STRINGS die Implementierung.
GET
Du möchtest eine Zeile aus der String Tabelle lesen? Mit der GET Methode kannst du dies tun, um ein STRING Objekt zu erhalten und damit weiterzuarbeiten oder den Inhalt zu lesen.
" Classic
READ TABLE lt_strings INDEX 5 INTO ld_string.
" Modern
ld_string = lt_strings[ 5 ].
" XCO
ld_string = xco_cp=>strings( lt_strings )->get( 5 )->value.
Hinweis: In den beiden letzten Fällen musst du dich um die Behandlung der Ausnahme CX_SY_ITAB_LINE_NOT_FOUND kümmern. Sollte die Zeile nicht existieren, so wird die Ausnahme ausgelöst.
Bereich
Mit den Methoden FROM und TO, kannst du einen Bereich aus einer Tabelle lesen und so Teile extrahieren. In dem Beispiel wollen wir einen Bereich aus der Mitte extrahieren.
" Classic
LOOP AT lt_strings INTO ld_string.
IF sy-tabix >= 2 AND sy-tabix <= 3.
APPEND ld_string TO lt_parts.
ENDIF.
ENDLOOP.
" Modern
LOOP AT lt_strings INTO ld_string FROM 2 TO 3.
INSERT ld_string INTO TABLE lt_parts.
ENDLOOP.
" XCO
lt_parts = xco_cp=>strings( lt_strings )->from( 2 )->to( 2 )->value.
Die Methode FROM, geht von dem TABIX 2 aus und liest die Sätze bis zum Ende. Die Methode TO nimmt dann das Ergebnis und liest von 1 bis 2, dieses Ergebnis erhalten wir dann in Parts. In dem Beispiel haben wir die Fehlerbehandlung weggelassen, da die XCO Klasse auch die Ranges überprüft, ob genügend Zeilen vorhanden sind.
Zusammenführen
Die COMPOSE Methode führt eine Tabelle von Strings nach gewissen Regeln zusammen und ist das Gegenstück zur DECOMPOSE Methode der String Klasse. Da die Logik etwas einfacher dafür ist, hier ein Beispiel.
" Classic
LOOP AT lt_strings INTO ld_string.
DATA(ld_field) = ld_string+0(1).
TRANSLATE ld_field TO UPPER CASE.
CONCATENATE ld_result ld_field ld_string+1 INTO ld_result.
ENDLOOP.
" Modern
LOOP AT lt_strings INTO ld_string.
ld_result &&= to_upper( substring( val = ld_string
len = 1 ) ) && substring( val = ld_string
off = 1 ).
ENDLOOP.
" XCO
ld_result = xco_cp=>strings( lt_strings )->compose( xco_cp_string=>composition->pascal_case )->value.
Sortierung
Bevor wir unsere Tabelle neu sortieren, benötigen wir die neue Reihenfolge. Dazu legen wir eine Indextabelle an mit den neuen Zeilen und der Reihenfolge.
DATA(lt_index) = VALUE if_xco_strings=>tt_indices( ( 3 ) ( 4 ) ( 5 ) ( 2 ) ( 1 ) ).
Dann können wir die eigentliche Logik durchführen, um unsere neue Ausgabetabelle zu erzeugen. Dazu verwenden wir die Methode REORDER der Klasse.
" Classic
LOOP AT lt_index INTO ld_index.
READ TABLE lt_strings INTO ld_string INDEX ld_index.
APPEND ld_string TO lt_parts.
ENDLOOP.
CLEAR lt_parts.
" Modern
LOOP AT lt_index INTO ld_index.
INSERT lt_strings[ ld_index ] INTO TABLE lt_parts.
ENDLOOP.
" XCO
lt_parts = xco_cp=>strings( lt_strings )->reorder( lt_index )->value.
Hinweis: In der Logik fehlt noch die Fehlerbehandlung, dann wäre der Code etwas länger. Die Logik der XCO Klasse prüft außerdem, dass keine Zeilen verloren gehen.
Umdrehen
Bei der Methode REVERSE wir die komplette Tabelle einmal umgedreht, sodass der letzte Satz der erste Satz wird. Dazu die folgenden Beispiele, die ebenfalls nicht sehr komplex sind.
" Classic
LOOP AT lt_strings INTO ld_string.
INSERT ld_string INTO lt_parts INDEX 1.
ENDLOOP.
" Modern
LOOP AT lt_strings INTO ld_string STEP -1.
INSERT ld_string INTO TABLE lt_parts.
ENDLOOP.
" XCO
lt_parts = xco_cp=>strings( lt_strings )->reverse( )->value.
XSTRING
Über XCO_CP=>XSTRING erhalten wir ein Objekt zur Behandlung von XStrings im System. Im Interface IF_XCO_XSTRING findest du die entsprechenden Methoden für die Verwendung und in der Klasse CL_XCO_XSTRING die Implementierung.
Konvertierung
Aktuell gibt es nur eine Methode zur Konvertierung von XString zu String mit einer entsprechenden Konvertierung. Ein Beispiel könnte also wie folgt aussehen.
" Classic
CALL FUNCTION 'ECATT_CONV_XSTRING_TO_STRING'
EXPORTING
im_xstring = c_xstring
IMPORTING
ex_string = ld_string.
" Modern
ld_string = cl_abap_codepage=>convert_from( source = c_xstring ).
" XCO
ld_string = xco_cp=>xstring( c_xstring )->as_string( xco_cp_character=>code_page->utf_8 )->value.
Performance
Wie sieht es eigentlich mit der Performance von Standard Statements aus, wenn wir die XCO Klassen verwenden. Dazu machen wir einen einfachen Test mit dem SPLIT in ABAP. In unserem Testversucht, erzeugen wir eine Tabelle von zufälligen Strings und verarbeiten diese Zeile für Zeile. indem wir die Texte wieder zerlegen. Dazu erzeugen wir zuerst eine Tabelle von zufälligen Strings.
DATA(lt_parts) = VALUE string_table( ( `Apple` )
( `Banana` )
( `Mango` )
( `Kiwi` )
( `Ananas` )
( `Orange` )
( `Citron` )
( `Lime` )
( `Cherry` )
( `Apricot` )
( `Plum` )
( `Pear` )
( `Blueberry` )
( `Grapes` )
( `Salmonberry` )
( `Raspberry` )
( `Honeydew` ) ).
DATA(lo_rand_strings) = NEW zcl_bs_demo_random( id_min = 1
id_max = lines( lt_parts ) ).
DATA(lo_rand_parts) = NEW zcl_bs_demo_random( id_min = 5
id_max = 10 ).
DO id_lines TIMES.
INSERT INITIAL LINE INTO TABLE rt_result REFERENCE INTO DATA(lr_line).
DO lo_rand_parts->rand( ) TIMES.
lr_line->* &&= | { lt_parts[ lo_rand_strings->rand( ) ] }|.
ENDDO.
ENDDO.
Im nächsten Schritt führen wir die Logik mit dem klassischen Split aus und zerlegen den String in seine Bestandteile.
LOOP AT lt_strings REFERENCE INTO lr_string.
SPLIT lr_string->* AT c_seperator INTO TABLE lt_split.
ENDLOOP.
Im zweiten Schritt verwenden wir die SPLIT Methode der XCO Klasse, um an die verschiedenen Bestandteile zu kommen.
LOOP AT lt_strings REFERENCE INTO lr_string.
lt_split = xco_cp=>string( lr_string->* )->split( c_seperator )->value.
ENDLOOP.
Im ersten Schritt nehmen wir 5000 zufällige Zeilen und zerlegen die Tabelle Zeile für Zeile. Schauen wir uns die Laufzeit für die beiden Varianten an, dann fällt der Unterschied ins Auge. Die Verwaltung des Speichers für die Klassen und Instanzen ist knapp 5 bis 6 Mal so teuer, wie die einfache Verwendung des Statements.
Sollte dir die Performance an dieser Stelle nicht so wichtig sein, kannst du auch mit der XCO Klasse arbeiten, vor allem wenn noch weitere String Operationen mit den Daten geplant sind.
Vollständiges Beispiel
Hier findest du die gezeigten Beispiele in einer ausführbaren Klasse zum Testen und Debuggen. Für den Performancetest verwenden wir zwei Klassen, die nicht im Beispiel aufgeführt sind. Weitere Informationen findest du im GitHub Repository.
CLASS zcl_bs_demo_xco_string DEFINITION
PUBLIC FINAL
CREATE PUBLIC.
PUBLIC SECTION.
INTERFACES if_oo_adt_classrun.
PRIVATE SECTION.
CONSTANTS c_string TYPE string VALUE `This is my new string class.`.
CONSTANTS c_long_string TYPE string VALUE `If you want to have a longer string for validation and to test, you have to create it for youself.`.
CONSTANTS c_xstring TYPE xstring VALUE `54686973206973206D79206E657720737472696E6720636C6173732E`.
CONSTANTS c_part TYPE string VALUE `ABAP`.
CONSTANTS c_point TYPE string VALUE `.`.
CONSTANTS c_seperator TYPE string VALUE ` `.
CONSTANTS c_regex TYPE string VALUE `w*isw*`.
METHODS split_performance
IMPORTING io_out TYPE REF TO if_oo_adt_classrun_out.
METHODS get_random_strings
IMPORTING id_lines TYPE i
RETURNING VALUE(rt_result) TYPE string_table.
METHODS operations_with_string
IMPORTING io_out TYPE REF TO if_oo_adt_classrun_out.
METHODS operations_with_strings
IMPORTING io_out TYPE REF TO if_oo_adt_classrun_out.
METHODS operations_with_xstring
IMPORTING io_out TYPE REF TO if_oo_adt_classrun_out.
ENDCLASS.
CLASS zcl_bs_demo_xco_string IMPLEMENTATION.
METHOD if_oo_adt_classrun~main.
operations_with_string( out ).
operations_with_strings( out ).
operations_with_xstring( out ).
split_performance( out ).
ENDMETHOD.
METHOD operations_with_string.
DATA ld_xstring TYPE xstring.
DATA(ld_string) = c_string.
" Classic
TRANSLATE ld_string TO UPPER CASE.
" Modern
ld_string = to_upper( c_string ).
" XCO
ld_string = xco_cp=>string( c_string )->to_upper_case( )->value.
" Classic
ld_string = c_string.
TRANSLATE ld_string TO LOWER CASE.
" Modern
ld_string = to_lower( c_string ).
" XCO
ld_string = xco_cp=>string( c_string )->to_lower_case( )->value.
" Classic
ld_string = c_string+11(3).
" Modern
ld_string = substring( val = c_string
off = 11
len = 3 ).
" XCO
ld_string = xco_cp=>string( c_string )->from( 11 + 1 )->to( 3 )->value.
" Classic
" TODO: variable is assigned but never used (ABAP cleaner)
SPLIT c_string AT c_seperator INTO TABLE DATA(lt_parts).
" Modern
" XCO
lt_parts = xco_cp=>string( c_string )->split( c_seperator )->value.
" Classic
CONCATENATE c_string c_part INTO ld_string.
" Modern
ld_string = c_string && c_part.
" XCO
ld_string = xco_cp=>string( c_string )->append( c_part )->value.
" Classic
DATA(ld_start) = strlen( c_string ) - strlen( c_point ) - 1.
DATA(ld_length) = strlen( c_point ).
IF c_string+ld_start(ld_length) = c_point.
ENDIF.
" Modern
IF substring( val = c_string
off = strlen( c_string ) - strlen( c_point ) - 1
len = strlen( c_point ) ) = c_point.
ENDIF.
" XCO
IF xco_cp=>string( c_string )->ends_with( c_point ).
ENDIF.
CLEAR lt_parts.
" Classic
FIND ALL OCCURRENCES OF PCRE c_regex IN c_string RESULTS DATA(lt_found).
LOOP AT lt_found INTO DATA(ls_found).
INSERT c_string+ls_found-offset(ls_found-length) INTO TABLE lt_parts.
ENDLOOP.
CLEAR lt_parts.
" Modern
ld_start = 0.
DO.
DATA(ld_position) = find( val = c_string
pcre = c_regex
off = ld_start ).
IF ld_position = -1.
EXIT.
ENDIF.
DATA(ld_to) = find_end( val = c_string
pcre = c_regex
off = ld_start ).
INSERT substring( val = c_string
off = ld_position
len = ld_to - ld_position ) INTO TABLE lt_parts.
ld_start = ld_to.
ENDDO.
" XCO
lt_parts = xco_cp=>string( c_string )->grep( iv_regular_expression = c_regex
io_engine = xco_cp_regular_expression=>engine->pcre( )
)->value.
lt_parts = xco_cp=>string( `MyNameIsPascal` )->decompose( xco_cp_string=>decomposition->pascal_case )->value.
" Classic
CALL FUNCTION 'SCMS_STRING_TO_XSTRING'
EXPORTING
text = c_string
IMPORTING
buffer = ld_xstring
EXCEPTIONS
failed = 1
OTHERS = 2.
IF sy-subrc <> 0.
ENDIF.
" Modern
ld_xstring = cl_abap_codepage=>convert_to( source = c_string ).
" XCO
ld_xstring = xco_cp=>string( c_string )->as_xstring( xco_cp_character=>code_page->utf_8 )->value.
" XCO
DATA(ls_message) = xco_cp=>string( c_long_string )->as_message( xco_cp_message=>type->error )->value.
" XCO
DATA(lo_message) = NEW cx_abap_context_info_error( ).
xco_cp=>string( c_long_string )->as_message( )->write_to_t100_dyn_msg( lo_message ).
ENDMETHOD.
METHOD operations_with_strings.
DATA ld_string TYPE string.
DATA lt_parts TYPE string_table.
DATA ld_result TYPE string.
DATA ld_index TYPE if_xco_strings=>tv_index.
DATA(lt_strings) = VALUE string_table( ( `This` )
( `is` )
( `the` )
( `strings` )
( `class` ) ).
" Classic
READ TABLE lt_strings INDEX 5 INTO ld_string.
" Modern
ld_string = lt_strings[ 5 ].
" XCO
ld_string = xco_cp=>strings( lt_strings )->get( 5 )->value.
" Classic
LOOP AT lt_strings INTO ld_string.
IF sy-tabix >= 2 AND sy-tabix <= 3.
APPEND ld_string TO lt_parts.
ENDIF.
ENDLOOP.
CLEAR lt_parts.
" Modern
LOOP AT lt_strings INTO ld_string FROM 2 TO 3.
INSERT ld_string INTO TABLE lt_parts.
ENDLOOP.
" XCO
lt_parts = xco_cp=>strings( lt_strings )->from( 2 )->to( 2 )->value.
CLEAR ld_result.
" Classic
LOOP AT lt_strings INTO ld_string.
DATA(ld_field) = ld_string+0(1).
TRANSLATE ld_field TO UPPER CASE.
CONCATENATE ld_result ld_field ld_string+1 INTO ld_result.
ENDLOOP.
CLEAR ld_result.
" Modern
LOOP AT lt_strings INTO ld_string.
ld_result &&= to_upper( substring( val = ld_string
len = 1 ) ) && substring( val = ld_string
off = 1 ).
ENDLOOP.
" XCO
ld_result = xco_cp=>strings( lt_strings )->compose( xco_cp_string=>composition->pascal_case )->value.
DATA(lt_index) = VALUE if_xco_strings=>tt_indices( ( 3 ) ( 4 ) ( 5 ) ( 2 ) ( 1 ) ).
CLEAR lt_parts.
" Classic
LOOP AT lt_index INTO ld_index.
READ TABLE lt_strings INTO ld_string INDEX ld_index.
APPEND ld_string TO lt_parts.
ENDLOOP.
CLEAR lt_parts.
" Modern
LOOP AT lt_index INTO ld_index.
INSERT lt_strings[ ld_index ] INTO TABLE lt_parts.
ENDLOOP.
" XCO
lt_parts = xco_cp=>strings( lt_strings )->reorder( lt_index )->value.
CLEAR lt_parts.
" Classic
LOOP AT lt_strings INTO ld_string.
INSERT ld_string INTO lt_parts INDEX 1.
ENDLOOP.
CLEAR lt_parts.
" Modern
LOOP AT lt_strings INTO ld_string STEP -1.
INSERT ld_string INTO TABLE lt_parts.
ENDLOOP.
" XCO
lt_parts = xco_cp=>strings( lt_strings )->reverse( )->value.
ENDMETHOD.
METHOD operations_with_xstring.
DATA ld_string TYPE string.
" Classic
CALL FUNCTION 'ECATT_CONV_XSTRING_TO_STRING'
EXPORTING
im_xstring = c_xstring
IMPORTING
ex_string = ld_string.
" Modern
ld_string = cl_abap_codepage=>convert_from( source = c_xstring ).
" XCO
ld_string = xco_cp=>xstring( c_xstring )->as_string( xco_cp_character=>code_page->utf_8 )->value.
ENDMETHOD.
METHOD split_performance.
DATA lo_run TYPE REF TO zcl_bs_demo_runtime.
DATA lr_string TYPE REF TO string.
DATA lt_split TYPE string_table.
DATA(lt_strings) = get_random_strings( 5000 ).
lo_run = NEW zcl_bs_demo_runtime( ).
LOOP AT lt_strings REFERENCE INTO lr_string.
SPLIT lr_string->* AT c_seperator INTO TABLE lt_split.
ENDLOOP.
io_out->write( |Native SPLIT : { lo_run->get_diff( ) }| ).
lo_run = NEW zcl_bs_demo_runtime( ).
LOOP AT lt_strings REFERENCE INTO lr_string.
lt_split = xco_cp=>string( lr_string->* )->split( c_seperator )->value.
ENDLOOP.
io_out->write( |XCO String Split : { lo_run->get_diff( ) }| ).
ENDMETHOD.
METHOD get_random_strings.
DATA(lt_parts) = VALUE string_table( ( `Apple` )
( `Banana` )
( `Mango` )
( `Kiwi` )
( `Ananas` )
( `Orange` )
( `Citron` )
( `Lime` )
( `Cherry` )
( `Apricot` )
( `Plum` )
( `Pear` )
( `Blueberry` )
( `Grapes` )
( `Salmonberry` )
( `Raspberry` )
( `Honeydew` ) ).
DATA(lo_rand_strings) = NEW zcl_bs_demo_random( id_min = 1
id_max = lines( lt_parts ) ).
DATA(lo_rand_parts) = NEW zcl_bs_demo_random( id_min = 5
id_max = 10 ).
DO id_lines TIMES.
INSERT INITIAL LINE INTO TABLE rt_result REFERENCE INTO DATA(lr_line).
DO lo_rand_parts->rand( ) TIMES.
lr_line->* &&= | { lt_parts[ lo_rand_strings->rand( ) ] }|.
ENDDO.
ENDDO.
ENDMETHOD.
ENDCLASS.
Fazit
Die XCO Klassen können an einigen Stellen Code sparen, vor allem wenn es um komplexere Aktionen geht. Hier jedes Mal Logik neu zu entwickeln und zu testen macht keinen Sinn. Daher eine klare Empfehlung zur Verwendung der Klasse, wenn es sich nicht um Standardoperationen handelt.
Quelle:
SAP Help - XCO String
