Ansicht
Dokumentation

ABAPSHEET_STRING_PROCESSING - SHEET STRING PROCESSING

rdisp/max_wprun_time - Maximum work process run time   CPI1466 during Backup  
Diese Dokumentation steht unter dem Copyright der SAP AG.

Stringverarbeitung

Dieser Spickzettel bietet einen Überblick über ausgewählte Syntaxoptionen beim Arbeiten mit Zeichenketten. Darüber hinaus bietet er Ihnen eine nützliche Referenzsammlung von Syntax- und Quelltextstücken. Weitere Informationen und Syntaxoptionen finden Sie im entsprechenden Abschnitt der ABAP-Schlüsselwortdokumentation.

Einleitung

ABAP bietet viele Möglichkeiten, Zeichenketten zu verarbeiten. Zu den Möglichkeiten gehören ABAP-Anweisungen, Zeichenkettenausdrücke und eingebaute Zeichenkettenfunktionen:

• Ausdrücke und Zeichenkettenfunktionen können dazu beitragen, den ABAP-Quelltext übersichtlicher und einfacher zu gestalten. Beispielsweise können Zeichenkettenoperationen direkt an Operandenpositionen durchgeführt werden und damit temporäre Variablen vermieden werden.

• In den meisten Fällen bieten Zeichenkettenfunktionen die gleiche Funktionalität wie die entsprechenden ABAP-Anweisungen. Wenn Zeichenkettenfunktionen Zeichenketten zurückgeben, sind die Zeichenketten immer vom Typ string.

• In ABAP-Anweisungen werden modifizierende Operationen auf Zeichenketten häufig auf dem Quellfeld ausgeführt, das gleichzeitig das Zielfeld ist. Zeichenkettenfunktionen verändern das Quellfeld nie. Stattdessen wird gegebenenfalls die modifizierte Zeichenkette als Rückgabewert zur Verfügung gestellt.

Typische Datentypen für Zeichenketten in ABAP sind:

• string

• Datenobjekte dieses Typs haben eine variable Länge, d.h. die Länge kann sich während der Ausführung von ABAP-Programmen ändern (daher werden sie auch als dynamische Datenobjekte bezeichnet).

• Wenn eine Zeichenkette variabler Länge deklariert wird, können rückwärts geneigte Hochkommata (`...`) verwendet werden. Senkrechte Striche ($|...$|; siehe Zeichenketten-Templates) können auch verwendet werden.

• c

• Datenobjekte dieses Typs haben eine feste Länge.

• Wenn eine Zeichenkette fester Länge deklariert wird, werden einfache Anführungszeichen ('...') verwendet.

Unterschiede zwischen Zeichenfolgen mit variabler Länge und fester Länge

• Initialwert; Der Initialwert einer Zeichenkette mit variabler Länge ist eine leere Zeichenkette mit der Länge 0. Zeichenketten mit fester Länge haben eine Standardlänge von einem Zeichen. Der Initialwert ist ein Leerzeichen.

• Leistung: Datenobjekte vom Typ c und string werden beide als elementare Datenobjekte betrachtet. Datenobjekte vom Typ string werden aber intern als Referenzen verwaltet und gelten somit als tief. Dies ermöglicht das Konzept der Leistungssteigerung der gemeinsamen Nutzung von Datenobjekten dieses Typs bei der Durchführung von Wertzuweisungen.

• Länge: Theoretisch kann eine Zeichenkette mit variabler Länge bis zu 2 GB verwenden. Die maximale Länge einer Zeichenkette mit fester Länge beträgt 262143 Zeichen.

• Behandlung von schließenden Leerzeichen: Zeichenketten mit fester Länge ignorieren normalerweise schließende Leerzeichen, Zeichenketten mit variabler Länge berücksichtigen sie.

• Flexibilität: Zeichenketten mit variabler Länge sind flexibler als Zeichenketten mit fester Länge, da sie leicht verkürzt oder erweitert werden können, ohne dass beispielsweise Zeichen bei der Verarbeitung abgeschnitten werden.

Also, wann soll man eigentlich was verwenden? Zeichenketten mit fester Länge sind sinnvoll, um tatsächlich eine maximale oder obligatorische Länge festzulegen, z.B. ein Länderkennzeichen, das aus maximal zwei Zeichen bestehen muss, oder Eingabefelder in Formularen, die eine bestimmte Länge nicht überschreiten sollten. Wenn das Einschränken einer Zeichenkette nicht relevant ist, sind Zeichenkette mit variabler Länge eine gute Wahl.

Für Zeichenketten mit fester Länge gibt es weitere zeichenartige Datentypen, z.B. n für numerische Textliterale. Die Standardlänge und der Wertebereich sind wie bei c, wobei nur Ziffern (0 bis 9) gültige Werte sind. Der Initialwert ist "0". Hier müssen darauf geachtet werden, da die Feldrestriktionen nicht erzwungen werden. Daher können Felder ungültige Daten enthalten. Der Typ wird insbesondere für Ziffern verwendet, die nicht für arithmetische Berechnungen vorgesehen sind, wie Postleitzahlen oder Artikelnummern.

DATA zip_code TYPE n LENGTH 5 VALUE '12345'.
DATA isbn_number TYPE n LENGTH 13 VALUE '1234567890123'.

Der Datentyp n, byteartige Datentypen (x, xstring), d (Datum) und t (Zeit) (die beide Spezialisierungen vom Typ c sind) sind nicht Teil dieses Spickzettels.

Zeichenartige Datentypen und Objekte deklarieren

Zeichenartige Datentypen und Objekte werden wie andere Typen und Objekte mit TYPES- und DATA-Anweisungen deklariert. Dieser Spickzettel konzentriert sich in den meisten Beispielen auf die eingebauten Typen c und insbesondere auf string .

Syntaxbeispiele:

"Type declarations using built-in types
TYPES: c_type   TYPE c LENGTH 3, "Explicit length specification
       str_type TYPE string.

"Data object declarations using built-in, local and DDIC types
DATA: flag  TYPE c LENGTH 1, "Built-in type
      str1  TYPE string, "Built-in type
      char1 TYPE c_type, "Local type
      str2  LIKE str_a1, "Deriving type from a local data object
      str3  TYPE str_type, "Local type
      char2 TYPE s_toairp, "DDIC type (used e. g. for a field in the SPFLI demo table)
      char3 TYPE spfli-carrid. "Using the type of a DDIC table component

"You might also stumble upon declarations with type c and the length
"specified in parentheses. Not recommended so as to not confuse with the
"use of parentheses in dynamic programming.
DATA char(4) TYPE c.

Erzeugen von Zeichenketten und Zuordnen von Werten

Zeichenketten werden erzeugt, indem zeichenartige Datenobjekte deklariert und ihnen Werte zuwiesen werden. Hier können direkt bei der Deklaration der Datenobjekte Standardwerte angegeben oder mit dem Zuweisungsoperator = Werte zugewiesen werden. Um beides auf einmal zu machen, Datenobjektdeklaration und Wertzuweisung, kann eine Inline-Deklaration verwendet werden, die Deklarationen an Schreibpositionenunterstützt. Dabei leitet eine in Klammern angegebene Variable mit vorangestelltem DATA auf der linken Seite des Zuweisungsoperators automatisch einen Datentyp aus dem rechten Operanden ab. Auf diese Weise können Programme schlanker gestaltet werden.

Syntaxbeispiele:

"Data object declarations including default values with VALUE
DATA: flag TYPE c LENGTH 1 VALUE 'X', "Single quotes
      str1 TYPE string VALUE `Hallo!`. "Backquotes

"More data object declarations
DATA: char  TYPE c LENGTH 5,
      html  TYPE string,
      str   LIKE html.

"Value assignments
char = 'ab123'.
html = `<p>hallo</p>`.
str  = `This is a backquote: ``.`. "Escape backquotes with another one
"If possible, avoid unnecessary type conversion
str = 'abc'. "Fixed-length string assigned to data object of type string

"Inline declarations
DATA(char_b) = 'abcd'.
DATA(str_b)  = `efgh`.
"Since char_b is of type c length 4 (the length is also derived),
"characters are truncated in the following example assignment
char_b = 'ijklmnopq'. "The data object is only assigned ijkl

"Treating trailing blanks
DATA(char_c) = 'ab   '.
DATA(str_c)  = `cdefgh`.
str_c = char_c. "Result: ab; trailing blanks are not respected

Verkettung von Zeichenketten

Bei der Zuweisung von Zeichenketten können nicht nur Datenobjekte auf der rechten Seite platziert werden. Verschiedene Ausdrücke und Zeichenketten können mit dem Verkettungsoperator && verkettet werden. Alternativ können die Zeichenketten mithilfe von Zeichenketten-Templates und den Optionen zum Verketten von Zeichenketten durchgeführt werden, wie weiter unten gezeigt.

text3 = text1 && ` ` && text2 && `!`.

Zeichenketten-Templates

Mit Hilfe von Zeichenketten-Templates können Zeichenketten aus Literalen und ABAP-Ausdrücken sehr elegant konstruiert werden. Die Zeichenkette wird mit dem senkrechten Strich am Anfang und Ende des Zeichenketten-Templates ($|...$|) konstruiert. Um Ausdrücke einzubetten, werden sie in geschweifte Klammern (${ expr $}) eingebettet. Wie oben erwähnt, können auch mehrere Zeichenketten mithilfe von Zeichenketten-Templates verkettet werden.

Syntaxbeispiele:

"Data object declarations
text1 = `Hallo`. "String created using backquotes.
text2 = |how|. "Strings created using pipes.
text3 = |are|.

"String construction using literals and expressions
"A blank (not within the curly brackets) means a blank in the resulting string.
"The expression must be convertible to a string.
text4 = |{ text1 } { cl_abap_syst=>get_user_name( ) }, { text2 } { text3} you?|.

"Chaining of string templates using && since string templates cannot stretch
"over multiple lines
text5 = |{ text1 } | && |and| && | goodbye.|

Zeichenketten-Templates interpretieren bestimmte Zeichenkombinationen als Steuerzeichen. Zum Beispiel wird \n als Hexadezimalwert zum Festlegen einer neuen Zeile interpretiert. Außerdem unterstützen Zeichenketten-Templates verschiedene Formatierungsoptionen. Prüfen Sie die ABAP-Schlüsselwortdokumentation für alle Optionen.

Syntaxbeispiele:

"Control characters
text4 = |{ text1 }\n{ text2 }\n{ text3 }\nyou?|. "\n interpreted as line breaks

"Various formatting options
"Time and date
"Formatting according to the user master data
date = |The date is { cl_abap_context_info=>get_system_date( ) DATE = USER }.|.
"Formatting in accordance with ISO 8601
time = |The time is { cl_abap_context_info=>get_system_time( ) TIME = ISO }.|.
"Formatting to UTC; date and time are represented in ISO 8601
ts = |Timestamp: { utclong_current( ) TIMESTAMP = SPACE }.|.

"Lower and upper case
t1 = |AbCdEfG|.
t2 = |{ t1 CASE = LOWER }|.
t3 = |{ t1 CASE = UPPER }|.

"Width and alignment
t4 = |{ 'Left' WIDTH = 20 ALIGN = LEFT }<---|.
t5 = |{ 'Center' WIDTH = 20 ALIGN = CENTER }<---|.
"PAD: Used to pad any surplus places in the result with the specified character.
t6 = |{ 'Right' WIDTH = 20 ALIGN = CENTER PAD = '.' }<---|.

"Numbers
t7 = |{ - 2 / 3 DECIMALS = 3 }|. "Format the result to only hold 3 decimals

• Zeichenketten-Templates können nicht in Benutzerdialogen verwendet werden, da sie übersetzbar sein müssen. Daher sollten diese Texte in OTR-Texten oder T100-Nachrichten realisiert werden.

• Das Fluchtsymbol \|{} in Zeichenketten-Templates mit \, d.h. \\ bedeutet \.

Ermitteln der Länge von Zeichenketten

Um die Länge einer Zeichenkette zu bestimmen, kann die Zeichenkettenfunktion strlen verwendet werden. Beachten Sie, dass das Ergebnis vom Typ des Literals abhängt, d.h. das Ergebnis eines Literals vom Typ string umfasst schließende Leerzeichen. Eine Zeichenkette mit fester Länge enthält sie nicht. Um schließende Leerzeichen unabhängig vom Datentyp in allen Fällen auszuschließen, kann die eingebaute Funktion numofchar verwendet werden.

Syntaxbeispiele:

"strlen
len_c   = strlen( 'abc   ' ). "3
len_str = strlen( `abc   ` ). "6

"numofchar
len_c   = numofchar( 'abc   ' ). "3
len_str = numofchar( `abc   ` ). "3

Konkatenieren von Zeichenketten

Wie oben bereits erwähnt, können zwei oder mehr Zeichenketten mit dem Verkettungsoperator && und Zeichenketten-Templates verkettet werden. Alternativ können CONCATENATE-Anweisungen verwendet werden. Es ist auch möglich, Zeilen interner Tabellen zu einer Zeichenkette zu verketten, um eine Schleife zu vermeiden. Auf modernere Weise kann die Zeichenkettenfunktion concat_lines_of verwendet werden.

Syntaxbeispiele:

"&& and string template
t1 = `Ha` && `llo`. "Hallo
t2 = `Ha` && `llo` && ` ` && txt1. "Hallo Hallo
t3 = |{ txt1 }? { txt2 }!|. "Hallo? Hallo Hallo!

"CONCATENATE statements
CONCATENATE t1 t2 INTO t3.
CONCATENATE t1 t2 t3 INTO DATA(t4). "Multiple data objects and target declared inline

"You can also add a separation sign using the addition SEPARATED BY
CONCATENATE t1 t2 INTO t SEPARATED BY space.
CONCATENATE t1 t2 INTO t SEPARATED BY '#'.

"Keeping trailing blanks in the result when concatenating fixed-length
"strings. The ones of variable-length strings are respected by default.
CONCATENATE 'a  ' 'b  ' 'c  ' INTO t RESPECTING BLANKS.

"Concatenating lines of internal tables into a string
CONCATENATE LINES OF itab INTO t SEPARATED BY space.
"Using concat_lines_of
t = concat_lines_of( table = itab ). "Without separator
t = concat_lines_of( table = itab sep = ` ` ). "With separator

Zeichenketten aufteilen

Mit SPLIT-Anweisungen können Zeichenketten in mehrere Segmente aufgeteilt werden. Das Ergebnis der Aufteilung kann in eigenen Datenobjekten oder internen Tabellen abgelegt werden, die einen zeichenartigen Zeilentyp haben. Wenn die angegebenen Ziele kleiner sind als die durch die Aufteilung abgerufenen Segmente, erhält das letzte Ziel den Rest der Segmente, die noch nicht aufgeteilt wurden. Wenn mehr Ziele angegeben sind, werden die Ziele initialisiert, die kein Segment erhalten. Daher ist die Angabe einzelner Ziele mit SPLIT-Anweisungen sinnvoll, wenn die Anzahl der erwarteten Segmente bekannt ist. Andernfalls ist die Aufteilung in Tabellen eine gute Wahl.

Wenn der Wert eines bestimmten Segments abgerufen werden soll, kann die Zeichenkettenfunktion segment verwendet werden.

Syntaxbeispiele:

t1 = `Hallo,world,12345`.
SPLIT t1 AT `,` INTO t2 t3 t4.
"Less data objects than possible splittings; t3 contains world,12345
SPLIT t1 AT `,` INTO t2 t3.
"Split into internal table
DATA itab TYPE TABLE OF string.
SPLIT t1 AT ',' INTO TABLE itab. "Strings added to itab without comma

"String function segment; index parameter: number of segment
seg = segment( val = t1 index = 2 sep = `,` ). "seg: world

Ändern von Zeichenketten

Verwandlung in Klein- und Großbuchstaben

Die Zeichenkettenfunktionen to_lower und to_upper verwandeln die Zeichen einer Zeichenkette in Groß- oder Kleinbuchstaben und legen das Ergebnis in eine Zielvariable ab. Wenn die Verwandlung direkt auf die Quelle angewendet werden soll, können TRANSLATE-Anweisungen verwendet werden.

Syntaxbeispiele:

"String functions
upper_case = to_upper( `abap` ). "ABAP
lower_case = to_lower( `SOME_FILE.Txt` ). "some_file.txt

"TRANSLATE statements
DATA(txt) = `Hallo`.
TRANSLATE txt TO UPPER CASE. "HALLO
TRANSLATE txt TO LOWER CASE. "hallo

Inhalt verschieben

Der Inhalt innerhalb einer Zeichenkette kann an eine bestimmte Position links oder rechts einer Zeichenkette verschoben werden. SHIFT-Anweisungen haben für bestimmte Anwendungsfälle unterschiedliche Zusätze.

Auf modernere Weise können die Zeichenkettenfunktionen shift_left und shift_right verwendet werden, die das Ergebnis in einer Variablen speichern. Diese Funktionen bieten eine zusätzliche Funktionalität. Der Parameter sub kann verwendet werden, um eine Teilzeichenkette anzugeben. Alle Teilzeichenketten in der Zeichenkette, die entweder auf der linken oder rechten Seite der Zeichenkette mit dem angegebenen Wert in sub übereinstimmen, werden entfernt.

Syntaxbeispiele:

"SHIFT statements
DATA(a) = `hallo`.
SHIFT a. "No addition; string shifted one place to the left: allo
SHIFT a BY 2 PLACES. "Without direction, left by default: llo
SHIFT a BY 3 PLACES RIGHT. "With direction, variable-length strings are extended: ___hallo
"Here, _ represents a blank.
DATA(b) = 'hallo'.
SHIFT b BY 3 PLACES RIGHT. "Fixed-length string: ___ha
"CIRCULAR addition: characters that are moved out of the string are
"added at the other end again
SHIFT a BY 3 PLACES LEFT CIRCULAR. "lohal
SHIFT a UP TO `ll`. "Move characters up to a specific character set: llo
"Deleting leading and trailing characters
DATA(c) = `   hallo   `.
DATA(d) = c.
SHIFT c LEFT DELETING LEADING ` `. "hallo___
SHIFT d RIGHT DELETING TRAILING ` `. "___hallo

"String functions with parameters
txt = shift_left( val = a places = 3 ). "lo
txt = shift_left( val = a circular = 2 ). "lloha

"Note that shift_right does not extend a variable-length string.
txt = shift_right( val = a places = 3 ). "ha
txt = shift_right( val = `blanks:   ` sub = ` ` ). "blanks:
txt = shift_right( val = `blanks:   ` ). "Same result: blanks:

Verdichten von Zeichenfolgen

Mit CONDENSE-Anweisungen oder der Zeichenkettenfunktion condense können Leerzeichen in Zeichenketten entfernt werden. Der Vorteil der Zeichenkettenfunktion besteht darin, dass auch beliebige Zeichen angegeben werden können, die entfernt werden sollen und nicht nur Leerzeichen.

Syntaxbeispiele:

"CONDENSE statements
DATA(a) = ' ab cd '.
DATA(b) = '    ef   gh ij   '.
DATA(c) = ' kl  mn   op '.
CONDENSE a. "Trailing and leading blanks are removed: ab cd
CONDENSE b. "It also replaces sequences of multiple blanks with a single blank: ef gh ij
CONDENSE c NO-GAPS. "Removes all blanks: klmnop
"When NO-GAPS is used with variable-length strings, trailing blanks remain removed.

"String function condense
DATA(d) = ` ab   cd `.
"No parameters specified, i. e. their default values are provided.
"Works like CONDENSE statement without the NO-GAPS addition.
txt = condense( d ). "ab cd
"Parameters del/to not specified. from parameter with initial string
"(could also be a text field literal: from = ' '). This way, leading and
"trailing blanks are removed.
txt = condense( val = d from = `` ). "ab   cd
"Parameter to specified with an initial string. No other parameters.
"Works like CONDENSE statement with the NO-GAPS addition.
txt = condense( val = d  to = `` ). "abcd
"Parameter del specifies the leading/trailing characters to be removed.
txt = condense( val = `##see###you##` del = `#` ). "see###you
"If from and to are specified along with del, leading/trailing
"characters specified in del are first removed. Then, in the remaining string, all
"substrings composed of characters specified in from are replaced with
"the first character of the string specified in the to parameter
txt = condense( val  = `  Rock'xxx'Roller` del  = `re `
                from = `x` to = `n` ). "Rock'n'Roll

Zeichenfolgen umkehren

Die Zeichenkettenfunktion reverse kehrt eine Zeichenfolge um:

res = reverse( `paba` ). "abap

Inhalt einfügen

Die Zeichenkettenfunktion insert fügt eine Teilzeichenkette an einer beliebigen Position innerhalb einer gegebenen Zeichenkette ein. Mit Hilfe verschiedener Parameter kann die gewünschte Zeichenkette aufgebaut werden:

• val: Ursprüngliche Zeichenkette.

• sub: Teilzeichenkette.

• off: Legt optional den Adressabstand (oder Offset) fest, d.h. die Position, an der die Teilzeichenkette hinzugefügt werden soll. Der Standardwert ist 0. Wenn die Funktion mit dem Standardwert verwendet wird, ähnelt das Ergebnis der Verkettung einer Zeichenkette mit && (wie res = sub && text).

Syntaxbeispiele:

res = insert( val = `abcghi` sub = `def` off = 3 ). "abcdefghi
res = insert( val = `abcghi` sub = `def` ). "defabcghi

Verarbeitung von Teilzeichenketten

Mit der Zeichenkettenfunktion substring kann die Position (Parameter off) und die Länge (len) einer Teilzeichenkette angegeben werden, die aus einer gegebenen Zeichenkette (val) extrahiert werden soll. Es muss mindestens eines der Parameter off oder len angegeben werden. Der Standardwert von off ist 0, d.h. bei Verwendung des Standardwerts wird die Teilzeichenkette ab dem Anfang der Zeichenkette extrahiert. Wenn len nicht angegeben ist, werden die restlichen Zeichen berücksichtigt. Wenn Offset und Länge größer als die tatsächliche Länge des Strings sind, kommt es zur Ausnahme CX_SY_RANGE_OUT_OF_BOUNDS .

Die Syntax für den Zugriff auf Teilzeichenketten durch Offset- und Längenangaben mit dem Pluszeichen (+) hinter einer Variablen kann auch vorkommen. Hier wird die Länge in Klammern angegeben. Die Angabe eines Sternchens (*) bedeutet, dass der Rest der verbleibenden Zeichenkette berücksichtigt wird. Diese Syntaxoption ermöglicht sogar den Schreibzugriff auf Teilzeichenketten für Zeichenketten mit fester Länge. Lesezugriffe sind sowohl für Zeichenketten mit fester Länge als auch für Zeichenketten mit variabler Länge möglich. Diese Syntax kann jedoch mit der Verwendung von Marken (Tokens) im Kontext der dynamischen Programmierung verwechselt werden.

Für die Behandlung von Teilzeichenketten stehen weitere Zeichenkettenfunktionen zur Verfügung, z.B. substring_after, substring_before, substring_from und substring_to.

Diese Funktionen bieten mehr Optionen in Bezug auf Parameter, z.B. einen regulären PCRE-Ausdruck, der weiter unten behandelt wird.

Syntaxbeispiele:

str = `Lorem ipsum dolor sit amet`.
res = substring( val = str off = 6 ). "ipsum dolor sit amet
res = substring( val = str len = 5 ). "Lorem
res = substring( val = str off = 6 len = 5 ). "ipsum

chars = 'Lorem ipsum dolor sit amet'.
res = chars+0(5). "Lorem
res = chars+12(*). "dolor sit amet
CLEAR chars+11(*). "Lorem ipsum
chars+0(5) = 'Hallo'. "Hallo ipsum dolor sit amet

"Further string functions
string = `aa1bb2aa3bb4`.
res = substring_after( val = string sub = `aa` ). "1bb2aa3bb4 (only the first occurrence is considered)
res = substring_after( val = string sub = `aA` occ = 2 len = 4 case = abap_false ). ""3bb4
res = substring_before( val = string sub = `b2`  ). "aa1b
res = substring_from( val = string sub = `a3` ). "a3bb4 (includes the substring in sub)
res = substring_to( val = string sub = `3b` ). "aa1bb2aa3b (includes the substring in sub)

Suchen und Ersetzen

In ABAP gibt es viele Möglichkeiten, Operationen mit Zeichenketten zu suchen und zu ersetzen. Dazu gehört die Verwendung der prominenten ABAP-Anweisungen FIND und REPLACE oder die moderneren eingebauten Zeichenkettenfunktionen wie find und replace mit ihrer beträchtlichen Anzahl von Zusätzen oder Parametern. Viele dieser Optionen unterstützen die Ausführung eher einfacher Operationen, die nur einzelne Zeichen oder komplexere, musterbasierte Operationen auf Zeichenfolgen mit regulären PCRE-Ausdrücken berücksichtigen.

Suche nach bestimmten Zeichen

• Die Vergleichsoperatoren CA (contains any) oder ihre Negation NA (contains not any) können in Vergleichsausdrücken verwendet werden, um festzustellen, ob ein Zeichen eines bestimmten Zeichensatzes in einer Zeichenkette enthalten ist. Ein solcher Ausdruck ist wahr, wenn mindestens ein Zeichen gefunden wird.

• Die Suche berücksichtigt Groß- und Kleinschreibung.

• Die Systemvariable sy-fdpos enthält den Offset des ersten gefundenen Zeichens. Wenn nichts gefunden wird, enthält sy-fdpos die Länge des Strings.

• Die Position 0 steht für die allererste Position.

• Die Zeichenkettenfunktion find_any_of und ihre Negation find_any_not_of geben den Offset des Vorkommens eines beliebigen Zeichens zurück, das in einer Teilzeichenkette enthalten ist.

• Wenn nichts gefunden wird, wird der Wert -1 zurückgegeben.

• Weitere optionale Parameter sind möglich. Beispielsweise bestimmt die Angabe von occ die Suchrichtung, d.h. ein positiver Wert bedeutet, dass von links nach rechts gesucht wird. Ein negativer Wert bedeutet, das von rechts nach links gesucht wird.

• Wenn die Position von Zeichen nicht von Interesse ist, sondern wie oft Zeichen in einer Zeichenkette vorkommen, können Sie die Zeichenkettenfunktionen count_any_of oder ihre Negation count_any_not_of.

• Um festzustellen, ob eine Zeichenkette nur eine bestimmte Menge von Zeichen enthält, können die Vergleichsoperatoren CO (contains only) oder ihre Negation CN (contains not only) in Vergleichsausdrücken verwendet werden.

• In Bezug auf CO ist ein Vergleich wahr, wenn der linke Operand nur Zeichen enthält, die auch im rechten Operanden enthalten sind. Falls der Vergleich nicht wahr ist, kann man die Position des ersten Zeichens aus Text, der nicht im Zeichensatz enthalten ist, über sy-fdpos abrufen. Bei CN ist ein Vergleich wahr, wenn eine Zeichenkette nicht nur Zeichen aus dem Zeichensatz enthält.

Syntaxbeispiele:

str = `cheers`.
IF str CA `aeiou` ... "true, sy-fdpos = 2
IF str NA `xyz`... "true, sy-fdpos = 6

res = find_any_of( val = str sub = `aeiou` ). "2
res = find_any_not_of( val = str sub = `c` ). "1

res = count_any_of( val = str  sub = `e` ). "2
res = count_any_not_of( val = str  sub = `s` ). "5

IF str CO `rs` ... "not true, sy-fdpos = 0
IF str CN `cheers` ... "not true, sy-fdpos = 6

Ersetzen bestimmter Zeichen in Zeichenketten

Die Zeichenkettenfunktion translate kann verwendet werden, um bestimmte Zeichen durch andere zu ersetzen. Hier bezeichnet der Parameter from die Zeichen, die in eine Zeichenfolge eingefügt werden sollen, und to gibt die Zielzeichen an. Die Ersetzung erfolgt folgendermaßen: Jedes in from angegebene Zeichen wird durch das Zeichen in to ersetzt, das sich an derselben Position befindet, d.h. das zweite Zeichen in from wird durch das zweite in to angegebene Zeichen ersetzt. Wenn es kein Äquivalent in togibt, wird das Zeichen in from aus dem Ergebnis entfernt.

Mit TRANSLATE-Anweisungen können Ersetzungen direkt auf dem Quellfeld durchgeführt werden.

Syntaxbeispiele:

str = `___abc_def_____ghi_`.
res = translate( val = str from = `hi_` to = `ZZ` ). "abcdefgZZ
res = translate( val = str from = `_`  to = `ZZ` ). "ZZZabcZdefZZZZZghiZ

"TRANSLATE statement. The value after USING is interpreted as a string composed of character pairs.
"Starting with the first pair, a search is performed in text for the
"first character in every pair and each occurrence is replaced with the
"second character of the pair.
TRANSLATE str USING `_.aZgY`. "...Zbc.def.....Yhi.

Suche nach Teilzeichenketten in Zeichenketten

• Für einfache Teilzeichenkettensuchen können in Vergleichsausdrücken die Vergleichsoperatoren CS (contains string) oder ihre Negation NS (contains no string) verwendet werden. Hier wird unabhängig von der Groß-/Kleinschreibung gesucht. Die Systemvariable sy-fdpos enthält den Offset der gefundenen Teilzeichenkette. Wenn die Teilzeichenkette nicht gefunden wird, enthält sy-fdpos die Länge der gesuchten Zeichenkette.

• Für komplexere und iterierende Suchvorgänge kann es sinnvoll sein, FIND-Anweisungen oder die Zeichenkettenfunktion findzu verwenden. Wenn nur an dem Offset einer Teilzeichenkette innerhalb einer Zeichenkette Interesse besteht, bietet die Zeichenkettenfunktion mehr Optionen als den logischen Operator. Beispielsweise kann angegeben werden, ob bei der Suche die Groß-/Kleinschreibung beachtet werden soll oder nicht. Die Suche kann auch über Parameter weiter eingeschränkt werden.

• Mit der Zeichenkettenfunktion count kann festgestellt werden, wie oft eine Teilzeichenkette vorkommt. Es stehen spezielle Varianten zur Verfügung: count_any_of, count_any_not_of.

• Da die Zeichenkettenfunktion find aus der ABAP-Anweisung FIND abgeleitet wird, deckt FIND auch die gleiche Funktionalität wie oben beschrieben ab und verwendet die hier nicht behandelten Zusatzoptionen. FIND -Anweisungen speichern aber die Ergebnisse aller Vorkommen von Teilzeichenketten innerhalb einer Zeichenkette in einer internen Tabelle vom Typ MATCH_RESULT_TAB. Beispielsweise enthält die Komponente Offset die Position eines einzelnen Vorkommens. Weiterhin können interne Tabellen mit zeichenartigem Datentyp durchsucht werden.

Syntaxbeispiele:

str = `cheers`.
IF str CS `rs` ... "true, sy-fdpos = 4
IF str NA `xyz`... "not true, sy-fdpos = 6

"String function find
txt = `Pieces of cakes.`.
res = find( val = txt sub = `OF` case = abap_false  ). "7
res = find( val = txt sub = `hallo` ). "-1 (no finding returns -1)
res = find( val = txt sub = `ce` off = 1 len = 7 ). "3
"Parameter occ: Positive value means the nth position from the left,
"a negative value the nth position from the right
res = find( val = txt sub = `es` occ = -1 ). "13

"String function count
res = count( val = txt sub = `es` ). "2

"Return all positions of findings in an internal table.
"Using inline declaration, the internal table receives the appropriate type automatically.
FIND ALL OCCURRENCES OF SUBSTRING `es` IN txt RESULTS DATA(itab).
"itab has two lines including 4 and 13 in the offset component

"Search in internal tables and return all positions
DATA(tab) = VALUE string_table( ( `abcdZZ` ) ( `efgZZh` ) ( `ZZijkl` ) ).
FIND ALL OCCURRENCES OF SUBSTRING `ZZ` IN TABLE tab RESULTS DATA(it).
"The table it has 3 lines including these offsets for the findings: 4, 3, 0

Ersetzen von Teilzeichenketten in Zeichenketten

Um das Ergebnis einer Teilzeichenkettenersetzung in einer separaten Variablen zu speichern, kann replace verwendet werden. Mit REPLACE-Anweisungen können Ersetzungen direkt auf Zeichenketten (einschließlich Teilzeichenketten, die mit der Zeichenkettenfunktion nicht möglich sind) vorgenommen werden. Hinsichtlich der verschiedenen Zusätze von REPLACE bietet REPLACE eine syntaktische Ähnlichkeit mit FIND. Im Gegensatz zur Funktion find kann der Suchbereich nicht durch replaceeinschränkt werden. Es gibt jedoch den Parameter with, der den Ersetzungstext angibt. Zu den Parametern:

• sub: Gibt die zu ersetzende Teilzeichenkette an.

• case: Legt die Berücksichtigung von Groß- und Kleinschreibung fest.

• occ: Gibt die Anzahl der Vorkommen einer Teilzeichenkette an. Der Standardwert ist 1, d.h. das erste Vorkommen beginnend von links. Das Setzen von occ auf 0 bedeutet, dass alle Vorkommen für die Ersetzung berücksichtigt werden.

Syntaxbeispiele:

str = `abc def ghi abc`.
t = replace( val = str sub = `def` with = `###` ). "abc ### ghi abc
t = replace( val = str sub = `ABC` with = `###` case = abap_false occ = 2 ). "abc def ghi ###
t = replace( val = str sub = `abc` with = `###` occ = 0 ). "### def ghi ###

"REPLACE statements with selected additions
REPLACE `abc` IN str WITH `###`. "### def ghi abc
REPLACE ALL OCCURRENCES OF `abc` IN str WITH `###`. "### def ghi ###
REPLACE `aBC` IN str WITH `###` IGNORING CASE. "### def ghi abc
REPLACE SECTION OFFSET 4 LENGTH 7 OF str WITH `###`. "abc ### abc

Musterbasiertes Suchen und Ersetzen in Zeichenketten

Komplexe Such- und Ersetzungsvorgänge können basierend auf Mustern ausgeführt werden. Reguläre PCRE-Ausdrücke unterstützen die effektive Verarbeitung von Zeichenketten. Reguläre POSIX-Ausdrücke sollten nicht mehr verwendet werden, da sie obsolet sind. Reguläre XPath- und XSD-Ausdrücke werden hier nicht behandelt.

Einfache musterbasierte Suche mit Vergleichsoperatoren

Für einfache Muster kann der Vergleichsoperator CP (conforms to pattern) oder ihre Negation NP (does not conform to pattern) in Vergleichsausdrücken verwendet werden, um zu ermitteln, ob eine Menge von Zeichen, die einem bestimmten Muster entspricht, in einer Zeichenkette enthalten ist. Für die Muster können folgende Sonderzeichen verwendet werden:

Sonderzeichen	Details
*	Beliebige Zeichenfolge (einschließlich Leerzeichen).
+	Beliebiges Zeichen (nur ein Zeichen, einschließlich Leerzeichen).
#	Fluchtsymbol Das folgende Zeichen wird für einen exakten Vergleich gekennzeichnet.

Bei Mustern wird außer durch # gekennzeichneten Zeichen die Groß- und Kleinschreibung nicht berücksichtigt. Wenn ein Muster gefunden wird, gibt die Systemvariable sy-fdpos den Offset des ersten Vorkommens zurück. Andernfalls enthält sie die Länge der gesuchten Zeichenkette.

str = `abc_def_ghi`.
"Pattern: f is preceded by any character sequence, must be followed
"by _ and then followed by any character sequence
IF str CP `*f#_*`. ... "true; sy-fdpos = 6

"Pattern: i is not followed by another character
IF str NP `i+`. ... "true; sy-fdpos = 11 (length of searched string)

Komplexe Suche und Ersetzung durch reguläre Ausdrücke

Exkurs: Common Regular Expressions

Es gibt verschiedene Möglichkeiten, komplexe Suchen in Zeichenketten mit PCRE-Ausdrücken durchzuführen. Sie können recht komplex sein. Die folgende Übersicht zeigt gängige PCRE-Ausdrücke mit einfachen Beispielen.

Zeichen und Zeichentypen

Ausdruck	Stellt dar	Beispiel	Entspricht	Entspricht nicht
.	Ein beliebiges Zeichen	.	a, 9, Ä, #	aa, leer
\d	Eine beliebige Ziffer (0-9)	\d	1, 3, 7	A, b, c
\D	Jedes Zeichen, das keine Ziffer ist, entspricht [^0-9]	\D	D, e, f	4, 5, 8
\s	Beliebiges Leerraumzeichen wie Leerzeichen, Tabulator und neue Zeile	\s \lbr (Zeichenkette: hi there)	Das Leerzeichen dazwischen	hi
\S	Ein beliebiges Zeichen, das kein Leerraumzeichen ist	\S \lbr (Zeichenkette: a 1)	a, 1	Das Leerzeichen dazwischen
\w	Ein beliebiges Wortzeichen (Buchstabe, Ziffer oder Unterstrich), äquivalent zu [a-zA-Z0-9_]	\w \lbr (Zeichenkette: ab 12)	a, b, 1, 2	Das Leerzeichen dazwischen
\W	Jedes Zeichen, das kein Wortzeichen ist, entspricht [^a-zA-Z0-9_]	\W \lbr (Zeichenkette: cd 34)	Das Leerzeichen dazwischen	c, d, 3, 4
\...	Sonderzeichen wie [ ] \ / ^ können mit \ maskiert werden.	\\	\	/

Wiederholungen und Alternativen

Ausdruck	Stellt dar	Beispiel	Entspricht	Entspricht nicht
r*	Keine oder mehrere Wiederholungen von r	ab*	a, ab, abb, abbb	b, aba
r+	Eine oder mehrere Wiederholungen von r	ab+	ab, abb, abbb	a, b, aba
r{m,n}	Zwischen m und n Wiederholungen	a{2,4}	aa, aaa, aaaa	a, aaaaa, aba
r{m}	Genau m Wiederholungen	a{3}	aaa	a, aa, aaaa, bbb
r?	Optionales r	ab?a	aa, aba	abba, aca
r|s	Passende Alternativen, nämlich r oder s	a+|b+	a, b, aa, bb, aaa	ab, aabb

Zeichensätze, Bereiche, Untergruppen und vorrausschauende Zusicherungen (Lookarounds)

Ausdruck	Stellt dar	Beispiel	Entspricht	Entspricht nicht
[aA1-]	Zeichensatz, stimmt mit einem einzelnen Zeichen in der Liste überein	[aA1-]	a, A, 1, -	b, B, cc, 3
[a-z0-9]	Zeichenbereich, entspricht einem einzelnen Zeichen im angegebenen Bereich (Bereiche können gebietsschemaabhängig sein)	[a-c0-5]	b, c, 2, 4	d, Z, x, 9
[^aA1]	Negation, stimmt mit einem einzelnen Zeichen überein, das nicht in der Liste vorhanden ist	[^aA1]	b, C, 3, -	a, A, 1
[^0-9]	Negation, entspricht einem beliebigen einzelnen Zeichen außerhalb des Bereichs	[^0-9]	a, B, c	1, 2, 3
(...)	Erfassung Gruppe-zu-Gruppe-Teile von Mustern	a(b|c)a	aba, aca	aa, abca
(?=...)	Positiv vorausschauend, gibt Zeichen zurück, auf die ein angegebenes Muster folgt, ohne dieses Muster einzuschließen	a(?=b) \lbr (Zeichenkette: abc ade)	das erste a	das zweite a
(?!...)	Negativ vorausschauend, gibt Zeichen zurück, auf die kein angegebenes Muster folgt, ohne dieses Muster einzuschließen	a(?!b) \lbr (Zeichenkette: abc ade)	das zweite a	das erste a
(?<=...)	Positiv zurückblickend, gibt Zeichen zurück, denen ein angegebenes Muster vorangestellt ist, ohne dieses Muster einzuschließen	(?<=\s)c \lbr (Zeichenkette: ab c abcd)	das erste c, da ihm ein Leerzeichen vorangestellt ist	das zweite C
(?<!...)	Negativ zurückblickend, gibt Zeichen zurück, denen kein angegebenes Muster vorangestellt ist, ohne dieses Muster einzuschließen.	(?<!\s)c \lbr (Zeichenkette: ab c abcd)	das zweite c, da ihm kein Leerzeichen vorangestellt ist	das erste c

Untergruppen eignen sich bei Ersetzungen. Mit einem Ausdruck mit $ und einer Zahl, z.B. $1, kann eine bestimmte Gruppe referenziert werden. Beispiel: Die Zeichenkette abcde. Ein PCRE-Ausdruck kann (ab|xy)c(d.)sein, d.h. es sind zwei Untergruppen angegeben. In einem Ersetzungsmuster kann die erste Gruppe mit $1 und die zweite Gruppe mit $2 referenziert werden. Daher führt das Ersetzungsmuster $2Z$1 zu deZab.

Anker und Positionen

Ausdruck	Stellt dar	Beispiel	Entspricht	Entspricht nicht
^	Zeilenanfang, alternativ: \A	^a. \lbr (Zeichenkette: abcde)	ab	bc
$	Zeilenende, alternativ: \Z	$ \lbr (Zeichenkette: abcde)	die Position direkt nach e	eine beliebige andere Position
\b	Wortanfang und Wortende	1) \bd \lbr 2) c\b \lbr (Zeichenkette: abc def)	1) d \lbr 2) c	1) a \lbr 2) f

Suche mit regulären Ausdrücken

Mehrere Zeichenkettenfunktionen unterstützen PCRE-Ausdrücke, indem sie den Parameter pcre anbieten, mit dem ein solcher Ausdruck angegeben werden kann. FIND- und REPLACE-Anweisungen unterstützen reguläre Ausdrücke mit dem Zusatz PCRE.

Die Zeichenkettenfunktion match arbeitet ausschließlich mit regulären Ausdrücken. Sie gibt eine Teilzeichenkette zurück, die mit einem regulären Ausdruck innerhalb einer Zeichenkette übereinstimmt. Für Vergleiche kann auch die Prädikatfunktion matchesverwendet werden, die wahr oder falsch zurückgibt, wenn eine Zeichenkette mit einem bestimmten Muster übereinstimmt oder nicht.

Syntaxbeispiele:

str = `Cathy's black cat on the mat played with Matt.`.

"Determining the position of the first finding
"Here, the parameter occ is 1 by default.
res = find( val = str pcre = `at.` ). "1

"Determining the number of all findings.
"Considers all a characters not followed by t, all at plus att
res = count( val = str  pcre = `at*` ). "6
"Considers all at plus att
res = count( val = str pcre = `at+` ). "4

"Extracting a substring matching a given pattern
str_w_email = `The email address is jon.doe@email.com.`.
res = match( val = str_w_email
             pcre = `\w+(\.\w+)*@(\w+\.)+(\w{2,4})` ). "jon.doe@email.com

"Predicate function matches
"Checking the validitiy of an email address
email = `jon.doe@email.com`.
IF matches( val  = email
            pcre = `\w+(\.\w+)*@(\w+\.)+(\w{2,4})` ).  "true
...
ENDIF.

"Examples with the FIND statement
"Storing submatches in variables.
FIND PCRE `(.*)\son\s(.*)` IN str IGNORING CASE SUBMATCHES a b.
"a: Cathy's black cat, b: the mat played with Matt.

"Determinging the number of letters in a string
FIND ALL OCCURRENCES OF PCRE `[A-Za-z]` IN str MATCH COUNT a. "36

"Searching in an internal table and retrieving line, offset, length information
DATA(itab) = value string_table( ( `Cathy's black cat on the mat played with the friend of Matt.` ) ).
FIND FIRST OCCURRENCE OF PCRE `\bt.` IN TABLE itab
  IGNORING CASE MATCH LINE a MATCH OFFSET b MATCH LENGTH c. "a: 1, b: 21, c: 2

Ersetzen mit regulären Ausdrücken

Um Ersetzungsoperationen mit regulären Ausdrücken durchzuführen, können die Zeichenkettenfunktion replace und REPLACE-Anweisungen mit dem Parameter pcre bzw. dem Zusatz PCRE verwendet werden. Ähnlich wie die find-Funktion und FIND-Anweisungen bieten die replace-Funktion und REPLACE-Anweisungen eine Vielzahl von Parametern bzw. Zusätzen, um den zu ersetzenden Bereich weiter einzuschränken. Weitere Informationen finden Sie in der ABAP-Schlüsselwortdokumentation. Das ausführbare Beispiel umfasst zahlreiche oben aufgeführte PCRE-Ausdrücke mit der Funktion replace .

Syntaxbeispiele:

s = `ab apppc app`.
r = replace( val = s pcre = `p{2,4}` with = `#` ). "ab a#c app
r = replace( val = s pcre = `[^ac]` with = `#` ). "a# apppc app
r = replace( val = s pcre = `[^ac]` with = `#` occ = 0 ). " "a##a###c#a## (all occurrences)
r = replace( val = s pcre = `\s` with = `#` occ = 0 ). "ab#apppc#app

"Replacements with subgroups
r = replace( val  = s       pcre = `(.*?)PPP(.*)`
             with = `$2#$1` case = abap_false ). "c app#ab a

"Changing the source field directly with a REPLACE statement
REPLACE PCRE `(.*?)PPP(.*)` IN ss WITH `$2#$1` IGNORING CASE. "c app#ab a

Demonstrationsprogramm

Das Beispiel Zeichenkettenverarbeitung demonstriert die oben beschriebenen Syntaxvarianten in einem Programm.

RFUMSV00 - Advance Return for Tax on Sales/Purchases   General Data in Customer Master  
Diese Dokumentation steht unter dem Copyright der SAP AG.

Length: 67302 Date: 20240523 Time: 145249     sap01-206 ( 637 ms )