Regular Expressions

1 ) Einzelzeichen

‚A‘ für Einzelzeichen, Groß-Kleinschreibungssensitiv.

‚\‘ vorangestellt für Sonderzeichen, z.B. ‚\.‘

2) Platzhalter für Einzelzeichen

‚.‘ für ein Zeichen

‚\C‘ für ein Zeichen

‚\d‘ für eine Ziffer digital

2) Mengen

‚[‚ Anfang einer Menge z.B.: [ABC] jeweils ein Zeichen, [AB][BC] steht dann für zwei Zeichen

‚]‘ Ende einer Menge

‚^‘ Negation einer Menge, nur direkt nach ‚[‚ z.B.:[^ABC]

‚-‚ Bereich einer Menge z.B.:[A-Za-z0-9]

Spezielle Zeichenklassen innerhalb von [ ] wie

[:alnum:]: [:alpha:], [:digit:] oder \d

[:cntrl:]

[:print:]: [:graph:], [:blank:]

[:lower:] oder \l, [:upper:] oder \u

[:punct:]

[:space:] oder \s: [:blank] + Vorschübe

[:word:] oder \w: [:alnum:] und ‚_‘

[:unicode:], [:xdigit:]

z.B.: [[:alnum:]]

3) Sonderzeichenaufhebung

Durch vorangestelltes ‚\‘ oder Einschließen in ‚\Q‘ und ‚\E‘

4) Zeichenfolgen

rs Einfache Verkettung von zwei regulären Ausdrücken r und s

Operatoren für Zeichenfolgen:

Verkettungsoperatoren:

‚{‚ ‚}‘

‚*‘

‚+‘

‚?‘

Alternativoperator:

‚|‘

Untergruppen:

‚(‚ ‚)‘ ‚(?:‘ ‚)‘

Register

‚\‘

a) Verkettungen

rs für Verkettung von r und s

r{n} für n fache Verkettung von r

r{0} für leere Zeichenfolge ???

r{n,m} für mind. n, max. m Verkettungen von r

r{n,} für mind. n Verkettung von r

r* gleich r{0,} für leere Zeichenfolge oder beliebige Verkettung von r

r? gleich r{0,1} für leere Zeichenfolge oder r

r+ gleich r{1,} für Verkettung von r (gieriges Verhalten)

Verkettungsoperatoren binden stärker z.B.: Tral+a bindet mit l.

b) Alternativen

r|s Alternativ regulärer Ausdruck r oder s

Alternativen binden schwächer als Verkettungen

r|st entspricht also r|(?:st)

r|s+ entspricht also r|(?:s+)

c) Untergruppen

(r) gleich (?:r) gleich r

(r) speichert Teilfolgen in Register

(?:r) speichert Teilfolgen nicht in Register

d) Register

Diese werden nach dem regulären Ausdruck eingegeben und können bei Find und Replace dann verwendet werden

z.B.: ([„‚]).+\1 ist erfolgreich für alle Ausdrücke, die mit “ oder ‚ anfangen (Das Teilergebnis wird in \1 gespeichert) und mit “ oder ‚ gespeichert in \1 aufhören.

e) Sonderzeichenaufhebung

z.B.: .+\Q\w\d\E ist erfolgreich für den Ausdruck abc\w\d.

5) Suchmuster

6) Ersetzungsmuster

7) Vereinfachte reguläre Ausdrücke

reguläre Syntax	vereinfachte Syntax
*	*
+	nicht unterstützt
{ }	\{ \}
( )	\( \)
[ ]	[ ]
|	nicht unterstützt
(?= ) (?! )	nicht unterstützt
(?: )	nicht unterstützt

d.h. Will ich { und } der regulären Syntax verwenden, so muss ich \ voranstellen.

Pattern (a) in der regulären Syntax ist erfolgreich bei a.

Pattern(a) in der vereinfachten Syntax ist erfolgreich bei (a).

Pattern \(.\) in der regulären Syntax ist erfolgreich bei (a).

Pattern (.) in der vereinfachten Syntax ist erfolgreich bei a.

DATA: regex TYPE REF TO cl_abap_regex,
      res   TYPE        match_result_tab.

CREATE OBJECT regex
  EXPORTING
    pattern      = 'a+'
    simple_regex = abap_false.
FIND ALL OCCURRENCES OF REGEX regex IN 'aaa+bbb' RESULTS res.

CREATE OBJECT regex
  EXPORTING
    pattern      = 'a+'
    simple_regex = abap_true.
FIND ALL OCCURRENCES OF REGEX regex IN 'aaa+bbb' RESULTS res. 

8) Suchergebnisse

ABAP-Schlüsselwortdokumentation

Die folgende Suche findet die Unterfolge ‚ababb‘ ab Offset 3. Die ebenfalls übereinstimmende Unterfolge ‚babboo‘ ab Offset 4 wird nach der „leftmost-longest“-Regel nicht gefunden.

d.h. es wird die erste links gefundene und dann die längste gefundene Zeichenfolge angezeigt. Obwohl ‚babboo‘ länger ist, ist sie nicht das Suchergebnis

Nach den Bindungsprioritäten gilt:

‚*‘ bindet am stärksten, gleichstark wie ‚+‘
vor
einfache Verkettung ‚a‘ mit ‚.‘ bzw. Verkettung ‚b‘ mit ‚.*‘
vor
Alternative ‚|‘

(a.)

| ( ( [ab] ) + )

| ( b ( (.)* ) )

a und ein beliebiges Zeichen

oder

a oder b

oder

b und ein oder mehrere beliebige Zeichen

DATA: moff TYPE i,
      mlen TYPE i.

FIND REGEX 'a.|[ab]+|b.*' IN 'oooababboo'
     MATCH OFFSET moff
     MATCH LENGTH mlen.

9) Bindungsprioriäten

Verkettungsoperatoren binden stärker als einfache Verkettungen
z.B.: Tral+a bindet mit l.

Alternativen binden schwächer als Verkettungen

10) Leftmost longest

The Leftmost Longest Rule

Often there is more than one way of matching a regular expression at a particular location, for POSIX basic and extended regular expressions, the „best“ match is determined as follows:

1. Find the leftmost match, if there is only one match possible at this location then return it.
2. Find the longest of the possible matches, along with any ties. If there is only one such possible match then return it.
3. If there are no marked sub-expressions, then all the remaining alternatives are indistinguishable; return the first of these found.
4. Find the match which has matched the first sub-expression in the leftmost position, along with any ties. If there is only on such match possible then return it.
5. Find the match which has the longest match for the first sub-expression, along with any ties. If there is only one such match then return it.
6. Repeat steps 4 and 5 for each additional marked sub-expression.
7. If there is still more than one possible match remaining, then they are indistinguishable; return the first one found

Leftmost-longest-Regel

Zuerst wird die am weitesten links stehende Teilfolge der Zeichenfolge ermittelt, auf die der reguläre Ausdruck passt (leftmost). Gibt es mehrere Teilfolgen, so wird die längste Folge gewählt (longest). Anschließend wird dieser Vorgang für die hinter der Fundstelle beginnende Restfolge wiederholt.

Beispiel

Für den regulären Ausdruck d*od* werden fünf Teilfolgen in „doobedoddoo“ gefunden: „do“ an Offset 0, „o“ an Offset 2, „dodd“ an Offset 5, „o“ an Offset 9 und „o“ an Offset 10.

DATA result_tab TYPE match_result_tab.
FIND ALL OCCURRENCES OF regex 'd*od*' IN 'doobedoddoo'
                     RESULTS result_tab.

Suche alle o mit eventuell vorgelagerten und nachgelagerten d´s.

doobedoddoo
01234567890

Offset 0: do, es bleibt obedoddoo

Offset 2: o, es bleibt bedoddoo

Offset 5: dodd, es bleibt oo

Offset 9: es bleibt o

offfset 10: es bleibt o

*&---------------------------------------------------------------------*
*& Report  ZHST_TEST08
*&
*&---------------------------------------------------------------------*
*&
*&
*&---------------------------------------------------------------------*

REPORT  zhst_test08.
DATA: text TYPE string.
DATA: pattern TYPE string.
DATA: moff TYPE i,
      mlen TYPE i.

text  = 'oooababboo'.
"text  = 'ooobabboo'.
pattern = `a.|[ab]+|b.*` .
FIND REGEX pattern IN text
     MATCH OFFSET moff
     MATCH LENGTH mlen.

WRITE:  / text.
WRITE: / pattern.
WRITE: /  moff, mlen,  text+moff(mlen).
write: /.
"ababb und nicht babboo.

text  = 'ooobabboo'.
FIND REGEX pattern IN text
     MATCH OFFSET moff
     MATCH LENGTH mlen.

WRITE:  / text.
WRITE: / pattern.
WRITE: / moff, mlen,  text+moff(mlen).
write: /.

DATA result_tab TYPE match_result_tab.
DATA wa TYPE LINE OF match_result_tab.

text  = 'doobedoddoo'.
pattern = 'd*od*'.
FIND ALL OCCURRENCES OF REGEX pattern IN text
                     RESULTS result_tab.

WRITE:  / text.
WRITE: / pattern.
LOOP AT result_tab INTO wa.
  WRITE: / wa-offset, wa-length, text+wa-offset(wa-length).
ENDLOOP.