Syntax von Regular Expressions

Die Grammatik dieses Text-Werkzeugs

Hier wird versucht, in knapper Form einen Überblick über die Syntax der Regular Expressions (RE, RegExp) zu geben.
Alle Angaben sind unverbindlich (!!), schon allein deshalb, weil sich die Syntax in den einzelnen Applikationen und deren Versionen etwas unterscheidet. 		Falls RE ein neues Thema für sie ist, dann besuchen sie die RE-Startseite oder folgen einem der dort angeführten Links.
→ Anwendung der RE in verschiedenen Programmen, → RE-Beispiele.
Regular Expressions Regular Expressions Einführung in das Thema 'Regular Expressions' (RE)
RE in Programmen RE in Programmiersprachen und Programmen
Regular Expressions Online Live RE Online Live mit RE experimentieren
Aufgaben Grundlegende Aufgaben: match, replace, store, split
Zeichen Jedes Zeichen in einer RE steht für sich selbst
Sonderzeichen Zeichen, die auch als RE-Operatoren verwendet werden
Klassen Zusammenfassung von mehreren Zeichen zu RE-Klassen
Position Die positions-abhängige Anwendung von Operatoren
Wiederholung Operatoren für die Wiederholung von Zeichen und Joker
Logische Operatoren Die logische Verknüpfung (UND, ODER, NICHT) von Regeln
Speichern Speichern von (Teil)-Ergebnissen zur weiteren Verarbeitung
Nachgestellte Operatoren Operatoren für die gesamte formulierte RE
Beispiele Programmierung an typischen Beispielen
Links Links zum Thema "Regular Expressions"

Aufgaben von Regular Expressions (RE)
Regular Expressions bieten leistungsfähige Funktionen zur Analyse und Aufarbeitung von Texten (Zeichenketten, Strings).
Die grundlegende Syntax (Grammatik) der RE ist gleich, die Anwendung je nach Programmiersprache etwas unterschiedlich.
AufgabeErklärung
match Ausführung von Tests mit einem String. Die Test-Vorschrift wird als RE formuliert. Das Ergebnis ist entweder true oder false.   Der Original-String bleibt unverändert. Das Ergebnis ist nur dann true, wenn der match mit der gesamten RE zutrifft, nicht mit einem Teil davon.
Anwendung: Entscheidung, ob ein String die gewünschten Kriterien erfüllt - Anschließend meist eine bedingte Verzweigung ( if ... ).
replace Ersetzen eines oder mehrerer Teil-Strings in einem String. Die Vorschrift dazu wird als RE formuliert. Als Ergebnis wird der veränderte String zurückgegeben. (Stichwort substitute).
store Speichern bzw Isolieren eines oder mehrerer Teil-Strings. Die Vorschrift dazu wird als RE formuliert. Als Ergebnis stehen beliebig viele gespeicherte Teile für die weitere Verarbeitung zur Verfügung, meist in einem Array.
split Eine Sonderform der Funktion "store": Aufspaltung eines Strings nach einer Vorschrift, die als RE formuliert ist. Als Ergebnis stehen beliebig viele gespeicherte Teile für die weitere Verarbeitung zur Verfügung, meist als Array (Stichwort auch explode). Der Trenn-String selbst (meist ein einzelnes Trennzeichen) ist in den Ergebnissen nicht enthalten !

Zeichen
Grundsätzlich steht jedes Zeichen in einer RE für sich selbst, d.h. ein A bezeichnet den Großbuchstaben A.
Ausnahmen ergeben sich aus den weiteren Syntax-Regeln (Sonderzeichen).
Beispiel:
$t = 'Das ist ein Test';
$t =~ m/s/;
ergibt true,   da s im String Test enthalten ist. Die Prüfung wird nach dem ersten match (3. Zeichen) abgebrochen. 		 

Sonderzeichen
Einige Zeichen wie z.B. $ dienen als Operatoren. Wenn diese Zeichen selbst dargestellt werden sollen, dann werden sie mit einem vorangestellten \ Backslash 'maskiert', z.B. als \$
SymbolNameHexBeschreibung
\$dollar\x24Dollar-Zeichen
\(opening paranthesis\x28Runde Klammer auf
\)closing paranthesis\x29Runde Klammer zu
\*asterisk\x2AStern
\+plus sign\x2BPluszeichen
\.period\x2EPunkt
\/slash\x2FSchrägstrich
\?question mark\x3FFragezeichen
\[opening bracket\x5BEckige Klammer auf
\\backslash\x5C Rückwärts-Schrägstrich (in PHP \\\ oder \x{5C} )
\]closing bracket\x5DEckige Klammer zu
\^caret (circimflex)\x5ECircumflex
\{opening brace\x7BGeschwungene Klammer auf
\|vertical bar\x7CSenkrechter Strich
\}closing brace\x7DGeschwungene Klammer zu
Darüber hinaus gelten folgende allgemeine Sonderzeichen:
\0null\x00 Null-Byte (in PHP als \x{0} )
\bbackspace\x08Zurück
\ttabulator (TAB)\x09Tabulator
\nnew line (LF)\x0ANeue Zeile
\vvertical tabulator\x0BVertikaler Tabulator
\fform feed (FF)\x0CNeue Seite
\rcarriage return (CR)\x0DWagen-Rücklauf
\x002-digit hex code Beliebiges Zeichen in Hex-Code \x00..\xFF
\x40 bezeichnet z.B. das Zeichen @
Vorsicht: Zeichen \x80..\xFF sind auf Windows-PC non-Standard codiert, d.h. vom lokal verwendeten Zeichensatz abhängig !
\x{0000} (4-digit) hex code Beliebiges → Unicode-Zeichen in Hex-Code \x0000..\xFFFF
\x{20AC} bezeichnet z.B. das   €   Zeichen (weltweit eindeutig).
● PHP kann ein Null-Byte \x{0} nur so codieren, einen Backslash \x{5C} am besten so.
Je nach Umgebung (z.B. in MediaWiki) gibt es auch Probleme mit anderen Sonderzeichen. Codieren sie in diesem Fall mit \x{*} - Das funktioniert immer und ist leicht lesbar. (ersetzen sie * durch den Hex-UniCode des Zeichens).
♦ Details zum Thema Zeichen-Codes.

Zeichen-Klassen
Klassen-Operatoren stehen jeweils für eine ganze Gruppe von Zeichen. Sie werden nicht von allen Programmen und Programmier-Sprachen unterstützt.
Verwenden sie in diesem Fall (PHP) die in [] angeführten User-Klassen.
SymbolBedeutungErklärung
\ddigit Ziffern 0..9, entspricht der Klasse [0-9] oder [\x30-\x39]
\d+ steht für mindestens eine Ziffer, \d{1,3} steht für 1..3 Ziffern.
\Dno digit Keine Ziffer - jedes Zeichen außer 0..9, entspricht der Klasse [^0-9]
\sspace WhiteSpace: Leerzeichen (\x20), Tabulator (\t \x09), NewLine(\n \x0A), VerticalTab(\v \x0B), FormFeed (\f \x0C) oder Carriage Return (\r \x0D).
\s entspricht daher der Klasse [ \t\n\v\f\r] - Leerzeichen direkt nach der [ !
\s+ steht für mindestens ein WhiteSpace-Zeichen.
\Sno space Kein WhiteSpace-Zeichen, entspricht der Klasse [^ \t\n\v\f\r] - ^ ist der NOT-Operator !
\wword Buchstaben, Zahlen und _ underline (underscore \x5F ), entspricht der Klasse [0-9A-Z_a-z]
\Wno word Alle außer den word-Zeichen, entspricht der Klasse [^0-9A-Z_a-z]
[ ]
[ - ]
[^ ] 		  User-definierte Klasse: Jedes Zeichen in [] zählt als match-Zeichen (auch Leerzeichen).
In [] werden alle Zeichen einzeln angeführt oder in [ - ] das erste und das letzte Zeichen in → ASCII bzw. → Unicode Reihenfolge.
$t =~ m/refe[r]+er/; ergibt true für 'referer' und 'referrer'
$t =~ m/M[ae][iy]er/; ergibt true für Mayer, Maier, Meier, ... false für Maler, Meer.
$t =~ m/^[A-Z]/; ergibt true, wenn das erste Zeichen ein Großbuchstabe ist.
Innerhalb von [] sind keine Sonderzeichen wirksam, dort steht jedes Zeichen für sich selbst.
$t =~ m/[A-Z$]/; ergibt true, wenn der String mindestens einen Großbuchstaben oder '$' enthält
Die Aussage wird umgekehrt, wenn der NOT-Operator ^ als erstes Zeichen in [] steht:
$t =~ m/[^0-9a-z]/; ergibt true, wenn der String mindestens ein Zeichen enthält, welches keine Ziffer oder kein Kleinbuchstabe ist.
Klassen können kombiniert werden:
$t =~ m/[\s\.,]/; ergibt true, wenn der String ein WhiteSpace-Zeichen, Punkt oder Beistrich enthält.
Mehrfach-Angaben in [] nicht durch Zeichen (blank, comma, ..) trennen, sonst werden diese in die Klasse mit aufgenommen !
Von-bis Klassen funktionieren sogar mit dem → EBCDIC-Zeichensatz, obwohl dort die Zeichen in anderer Reihenfolge codiert sind.
.joker Der Punkt steht für genau 1 beliebiges Zeichen außer \n (nach besonderer Einstellung auch \n ).
.+ steht für (mindestens) ein oder mehrere beliebige Zeichen
.* steht für beliebig viele (auch 'keine') Zeichen.
.{3} steht für genau 3 beliebige Zeichen.
.{1,3} steht für 1..3 beliebige Zeichen.
● Perl:   Bei Verwendung von use locale werden auch die de-Sonderzeichen äöüÄÖÜß zu den \w-Zeichen gezählt.
● PHP:   Codieren sie einen Bereich von Sonderzeichen mit \x{*}-\x{*} - Das funktioniert immer und ist leicht lesbar (ersetzen sie * durch die Hex-Code des ersten und des letzten Zeichens).

Position
Mit diesen Operatoren werden Regeln an bestimmte Positionen gebunden.
Symbol Bedeutung Erklärung
^ Zeilen-Anfang,
vorangestellt 		$t =~ m/^http:/; ergibt true , wenn 'http' am Zeilen-Anfang steht
$t =~ m/^(\w*)/; speichert das erste Wort einer Zeile in $1
$ Zeilen-Ende,
nachgestellt 		$t =~ m/\.txt$/; ergibt true, wenn '.txt' am Zeilen-Ende steht
$t =~ m/(\w*)$/; speichert das letzte Wort eines Textes in $1
\A Text-Anfang,
vorangestellt 		Für multiline-Anwendung.   ^ matcht an jedem Zeilen-Anfang,   /A nur am Text-Anfang.
/\A. / bezeichnet das erste Zeichen eines multiline-Textes.
\Z Text-Ende,
nachgestellt 		Für multiline-Anwendung. $ matcht an jedem Zeilen-Ende, /Z nur am Text-Ende.
/.\Z / bezeichnet das letzte Zeichen eines multiline-Textes.
    $t =~ m/.+@.+/; ergibt true, wenn @ vorkommt, jedoch nicht an Anfang oder Ende.
Die folgende Operatoren werden nur von manchen Programmen unterstützt. Auch die Definition von "Wortgrenze" ist variabel.
\>Wort-AnfangRegel trifft am Wort-Anfang zu.
\>Wort-Ende Regel trifft am Wort-Ende zu.
$t =~ m/\.dat\>/; ergibt true für alle Dateinamen *.dat, die als Worte in Strings vorkommen.
\b Wortgrenze
(border) 		Die Grenze zwischen \w und \W oder umgekehrt.
/\b./ ergibt true für alle Zeichen direkt nach einer Wortgrenze (inkl. das erste Zeichen).
/.\b/ ergibt true für alle Zeichen direkt vor einer Wortgrenze.
\BKeine Wortgrenze /\B./ ergibt true für alle Zeichen von Worten außer dem ersten.
/.\B/ ergibt true für alle Zeichen von Worten außer dem letzten.

Wiederholungen & Joker
Mit den Wiederholungs-Operatoren werden Regeln wiederholt angewendet, z.B. auf ↑ Joker (beliebige Zeichen) oder bestimmte ↑ Zeichen-Klassen. Es kann vorkommen, dass mehrere Regeln miteinander um Zeichen konkurrieren. In diesem Fall 'gewinnen' die gierigen (greedy) Varianten gegen die 'faulen' (lazy) Varianten.
SymbolWiederholung Erklärung
?0..1, nachgestellt Dieser Operator ist 'gierig', d.h. der vorangestellte Bereich (Zeichen oder String) wird nach Möglichkeit eingeschlossen.
$t =~ m/html?$/; ergibt true , wenn $t auf 'htm' oder 'html' endet.
$t =~ m/font-?[Ss]ize/; ergibt true, wenn der String 'fontSize' oder 'font-size' lautet.
?? 0..1, nachgestellt Dieser Operator ist 'faul', d.h. der vorangestellte Bereich wird nach Möglichkeit ausgeschlossen.
+1..n, nachgestellt Dieser Operator ist 'gierig', d.h. der vorangestellte Bereich (Zeichen oder String) wird nach Möglichkeit eingeschlossen.
$t =~ m/Har+er/; ergibt true für Harer, Harrer, false für Harter, Hacker.
+? 1..n, nachgestellt Dieser Operator ist 'faul', d.h. der vorangestellte Bereich wird nach Möglichkeit ausgeschlossen.
.genau 1 Zeichen Genauer: 1 beliebiges Zeichen außer \n (nach besonderer Einstellung auch \n )
$t =~ m/Ma.er/; ergibt true für Mayer, Maier, Maler, ...false für Meier, Macher, ..
*0..n, nachgestellt Dieser Operator ist 'gierig', d.h. so viele Einheiten des vorangestellten Bereichs wie möglich werden eingeschlossen.
$t =~ m/Hau.*er/; ergibt true für Hauer, Hauser, Hausner, ...
$t =~ m/(\w*)\s+(\w*)/; isoliert 2 beliebig lange Strings, die durch mindestens 1 Leerzeichen getrennt sind
$t =~ s/^\s*/; entfernt führende Leerzeichen
* ist gierig (greedy): der match wird mit dem verbleibenden Teilstring immer wieder versucht, so oft das möglich ist.
*? 0..n, nachgestellt Dieser Operator ist 'faul', d.h. der vorangestellte Bereich wird nach Möglichkeit ausgeschlossen.
{n}genau n-mal, nachgestellt Genaue Anzahl der Wiederholungen als ganze Zahl in geschwungenen Klammern.
$t =~ m/\d{10}/; ergibt true für 10-stellige österr. Sozialversicherungs-Nummern.
Damit lassen sich diese Funktionen anderer Sprachen ersetzen: left, right, mid,..
$t =~ m/(.{3})/; speichert die ersten 3 Zeichen in $1
$t =~ m/(.{4})$/; speichert die letzten 4 Zeichen in $1
$t =~ m/.{2}(.{3})/; ignoriert 2 Zeichen und speichert die folgenden 3 Zeichen in $1
{m,n} {min,max},
nachgestellt		 Anzahl der minimalen und maximalen Wiederholungen als ganze Zahlen.
Beide Argumente sind optional. Die Standardwerte (default) lauten m=0, n=∞
? entspricht {0,1},   + entspricht {1,},   . entspricht {1,1},   * entspricht {,}.
$t =~ m/\d{2,3}/; ergibt true für Texte mit 2- oder 3-stelligen Zahlen.
(?:)passive Gruppierung Gruppierung ähnlich wie in der Mathematik. Der Inhalt wird nicht gespeichert !
$t = "xyz";
$t =~ m/(x)(y)(z)/; ergibt $1='x' $2='y' $3='z'
$t =~ m/(x)(?:y)(z)/; ergibt $1='x' $2='z'

Logische Verknüpfung von Regeln
Ohne besondere Vereinbarung wird jede angeführte Regel automatisch UND-verknüpft.
Das bedeutet: Für einen match müssen alle angeführten Regeln erfüllt werden.
Für die ODER-Verknüpfung steht ein Operator zur Verfügung.
In diesem Fall genügt die Erfüllung einer der angeführten Regeln.
SymbolLogik Erklärung
  UND
AND 		Bei Vorliegen mehrerer Regeln werden diese immer UND-verknüpft.
Das wird ungefragt angenommen, daher gibt es dafür keinen Operator.
$t =~ m/^f.+\.dat$/;
ergibt true, wenn der Text mit f beginnt und mit .dat endet.
So findet man z.B. Dateinamen f*.dat   jedoch nicht f*.* oder *.dat
|
( | )
(?: ) | (?: ) 		ODER
OR		 Der ODER-Operator erlaubt die Anwendung einer von mehreren Regeln.
In komplexen Fällen begrenzt man die Reichweite des |-Operators mit ()
$t =~ m/(^From:|^To:) (Maier|Weber)/;
ergibt true, wenn der Text-Anfang entweder From oder To lautet, UND nach einem Leerzeichen einer der beiden Namen folgt.
Wenn auf beiden Seiten des ODER-Operators komplexe Regeln stehen, dann wird jede am besten in eine passive Gruppierung (?: ) eingeschlossen.
^NICHT
NOT		 Der NICHT-Operator dient zur Umkehrung von User-definierten Klassen:
$t =~ m/^test\.{3}[^0-9]/;
ergibt true wenn der Text mit test. beginnt UND die nachfolgenden 3 Zeichen keine Ziffer enthalten.
Damit findet man z.B. Dateinamen test.dat, test.txt, test.htm   jedoch nicht test1.dat, test.001 usw.

Speichern zur weiteren Verarbeitung
Damit werden alle Funktionen abgedeckt, welche Teile eines Strings entnehmen oder verändern, wie z.B. left(), right(), mid(), substr(), ...
Beispiele dazu im Kapitel ↑ Wiederholungen

Mit RE kann man diese Funktionen nicht nur 'nachbauen', man kann auch mehrere davon zu einem einzigen Befehl zusammenfassen. 		Mit der Verwendung runder () in RE werden automatisch Variable erzeugt, welche das Ergebnis eines RE-match enthalten.

Die Ergebnisse sind je nach Programmiersprache in Variablen mit festgelegten Namen und/oder in Arrays verfügbar.
Beispiel (Perl):
Der String $t enthält ein ISO-Datum.
Es wird geprüft, ob der String 3 Zifferngruppen enthält, welche durch - Zeichen getrennt sind.
Jede Zifferngruppe kann beliebig viele, jedoch mindestens eine + Ziffern \d enthalten und wird durch () gespeichert.
Die automatisch erzeugten Variablen sind $1, $2, $3, ...
Die Ergebnisse werden in der nächsten Zeile auf die Variablen $y, $m, $d übertragen.
$t = '2004-05-20';
if ( $t =~ m/(\d+)-(\d+)-(\d+)/ ) {
my($y,$m,$d)=($1,$2,$3);
}
ergibt
$y = 2004
$m = 05
$d = 20
In diesem Beispiel wird aus einem Dateinamen $fn die file-extension $fext entnommen. Dazu können 1..n beliebige Zeichen .+ vor einem Punkt \. stehen, der nachfolgende String .+ wird gespeichert.
Der Punkt muss maskiert werden, da er sonst als Operator interpretiert wird.
$fn = "test.txt";
if ( $fn =~ m/.+\.(.+)/ ) {
$fext = $1;
}
Hier wird die Funktion trim mit RE realisiert: Von einem String $t werden sowohl führende als auch nachfolgende Leerzeichen, Tabulatoren und ein allfälliges \n entfernt. Leerzeichen innerhalb des Strings bleiben erhalten.
$t=' abc 123 xyz ';
if($t=~m/^[\s]*(.*[^\s]+)/) {$t=$1;}

Nachgestellte Operatoren (Flags)
Diese Operatoren wirken auf die gesamte RE und werden dem eigentlichen RE nachgestellt. Sie können miteinander kombiniert werden, z.B. /ig
SymbolSyntaxErklärung
i/RE/i ignore case - case-insensitive, Groß- oder Kleinbuchstaben
g/RE/g global - so oft wie möglich wiederholen
m/RE/m multiline - match über mehrere Zeilen. Berücksichtigt CR und LF-Zeichen.
.* matcht in diesem Falle nicht mit CR und LF.
s/RE/s single line - behandelt den gesamten String als "eine Zeile".
.* matcht in diesem Falle auch über Zeilengrenzen hinweg.
Zum Inhaltsverzeichnis Homepage von PS-Trainer   >   Entwicklung   >   Regular Expressions   >   Regeln (Syntax)