Okt 2008

Reguläre Ausdrücke

 
 

Die Suche mit einem „Joker“ oder „Wild Card“ kennt jeder: matrix* liefert alle Dateien, die mit der Zeichenkette matrix anfangen. Wer sicherstellen will, dass die Suche auf JPEG-Bilder beschränkt bleibt, verwendet matrix*.jpg.

Das war einfach. Aber wie findet man heraus, ob eine Zeichenkette eine Emailadresse darstellt?

Reguläre Ausdrücke suchen nach Zeichenketten mit einem Muster. Postleitzahlen bilden z.B. einfache Muster, Emailadressen und HTML-Tags folgen einem komplexeren Muster.

Die Bestandteile von regulären Ausdrücken

Reguläre Ausdrücke werden mit speziellen Sonderzeichen gesucht. Die meisten regulären Ausdrücke starten mit ^ für den Anfang eines Strings und enden mit $ für das Ende des Strings.

Ein gewöhnliches Suchmuster besteht aus drei Teilen:

/^Suchmuster$/ Modifier

  • Zwei Schrägstriche grenzen das Suchmusters ein (so wie Hochkommas einen String begrenzen).
  • Das Suchmuster selbst bildet den Hauptteil.
  • Nach dem schliessenden Begrenzer folgen optionale „Modifier“, die das gesamte Suchmuster beeinflussen, z.B. ein i, das die Unterscheidung von Groß-/Kleinschreibung aufhebt.
                                                       /^Matrix$/
                                                       ||  |   ||
                        /: öffnende Begrenzung  <------+|  |   ||
                                                        |  |   ||
        ^: Sonderzeichen für Anfang des Strings  <------+  |   ||
                                                           |   ||
           Matrix: wörtlicher Teil des Suchmusters  <------+   ||
                                                               ||
                 $: Sonderzeichen für Ende des Strings  <------+|
                                                                |
                            /: Schliessender Begrenzer   <------+

Die meisten Zeichen sind für sich bereits ein Suchmuster. /Matrix/ sucht nach der Zeichenkette Matrix – das ist so wunderbar banal. Durch die Sonderzeichen für Anfang und Ende des Strings findet /^Matrix$/ Matrix in einem String, der genau "Matrix" und nicht mehr und nicht weniger enthält. Es ist also immer eine gute Tat, den Weißraum vor und nach einer Eingabe zu trimmen.

Suchmuster suchen häufig nach Zeichenfolgen, die am Anfang oder am Ende einer Worts oder eines Strings sitzen.

Das Metazeichen \b steht für Wortanfang und Wortende.

                                                     /\bFische\b/ 
                                                     ||   |   | |
                      /: öffnende Begrenzung  <------+|   |   | |
                                                      |   |   | |
                               \b: Wortgrenze  <------+   |   | |
                                                          |   | |
          Fische: wörtlicher Teil des Suchmusters  <------+   | |
                                                              | |
                                        \b: Wortgrenze <------+ |
                                                                |
                            /: Schliessender Begrenzer   <------+

findet Fische in "Fischers Fritz fischt frische Fische", nicht aber Fischers.

Ein senkrechten Strich | trennt Alternativen voneinander.

                                               /°Häßler|Haessler$/ 
                                                |   |  |    |   |
 ^: Sonderzeichen für Anfang des Strings <------+   |  |    |   |
                                                    |  |    |   |
    Häßler: wörtlicher Teil des Suchmusters  <------+  |    |   |
                                                       |    |   |
                                       |: oder  <------+    |   |
                                                            |   |
          Haessler: wörtlicher Teil des Suchmusters  <------+   |
                                                                |
                                   $: Ende des Strings   <------+

findet Häßler oder Haessler in einem String, der genau "Häßler" oder "Haessler" lautet.

Mit einem nachgestellten Fragezeichen darf das vorangehende Zeichen genau einmal oder gar nicht vorkommen kann. 

                                                      /Schrauben?/
                                                           |    |
        Schrauben: wörtlicher Teil des Suchmusters  <------+    |
                                                                |
?: das Zeichen vor ? darf einmal oder keinmal vorkommen  <------+

findet Schraube und Schrauben in einem String.

Modifier

Modifier sind der intuitivste Teil von regulären Ausdrücken – darum stehen sie hier ganz vorn. Modifier stehen am Ende des regulären Ausdrucks hinter dem schliessenden Begrenzer und legen globale Änderungen über den gesamten regulären Ausdruck.

In Javascript gibt es drei Modifier: g (global) veranlasst den Javascript-Interpreter, die Operation auf den gesamten String auszudehnen. Ansonsten sucht oder ersetzt der Interpreter nur erste Vorkommen des Suchmusters.

i (ignore case) schaltet die Unterscheidung zwischen Groß- und Kleinschreibung aus, die ansonsten der Standard ist

m (multiline) findet Suchmuster am Anfang oder am Ende einer Zeichenkette. Der Modifier m wird ab Javascript 1.5 interpretiert.

Basiszeichen, Metazeichen, Zeichenklassen und Wiederholungen

BasiszeichenMetazeichen
\w Buchstabe, Ziffer oder Unterstrich. findet alle Zeichen außer Zeilenende
\W Ein Sonderzeichen^ Anfang eines Strings
\d Eine Ziffer zwischen 0 bis 8$ Ende eines Strings
\D Ein Zeichen, das keine Ziffer ist| Alternativen
\s Ein Weißraum (Leerzeichen, Zeilenumbruch usw.)() Teile des Suchmusters abgrenzen
\S Jedes Zeichen außer Weißraum[] Zeichenklassen
\b Wortgrenze{} Replikatoren
\Bkeine Wortgrenze
ZeichenklassenReplikatoren
[xyz] beliebiger Buchstabe x, y oder z{n,m} mindestens n mal, höchstens m mal
[^xyz] jeder Buchstabe außer x, y oder z{n,} mindestens n mal
[0-9] jede Ziffer zwischen 0 bis 9{n} genau n mal
[a-z] jeder kleine Buchstabe von a bis z* 0 mal oder öfter, äquivalent zu {0,}
[A-Za-z0-9] alle Buchstaben und Ziffern+ 1 mal oder öfter, äquivalent zu {1,}
[a-zß-ü] alle Kleinbuchstaben und Umlaute? 0 oder 1 mal, äquivalent zu {0,1}

Kurzschreibweisen für Buchstaben, Ziffern und Leerzeichen

Die Basiszeichen suchen nach Buchstaben, Ziffern und Leerzeichen – teilweise sind sie eine Kurzschreibweise für Zeichenklassen. Groß- und Kleinschreibung unbedingt beachten!

\w
Findet alle Buchstaben, Zahlen und Unterstriche und kann auch durch die Zeichenklasse [a-zA-Z0-9_] dargestellt werden. Umlaute und ß hingegen zählen zu den Sonderzeichen.
Suche nach allen Strings, die mit Ha anfangen, gefolgt von zwei beliebigen Buchstaben, Zahlen oder Unterstrichen gefolgt von einem o:
/ Ha \w \w o / g ^ ^ ^ | | | | | +------> gefolgt von einem kleinen o  | | | +------> gefolgt von zwei Buchstaben, Zahlen oder Unterstrichen | +------> Suchmuster beginnt mit Ha String: Hallo Hanno! Hattest du Glück? Suchmuster: /Ha\w\wo/g Findet: Hallo und Hanno
\W
Findet alle Zeichen außer Buchstaben, Zahlen oder Unterstriche.
Sucht nach allen Strings, die nicht mit einem Buchstaben, einer Zahl oder einem Unterstrich anfangen gefolgt von einem Leerzeichen.
/\W /g ^^ || |+------> gefolgt von einem Leerzeichen | +------> Erstes Zeichen ist weder Buchstabe, Zahl noch Unterstrich String: Hallo Hanno! Hattest du Glück? Suchmuster: /\W /g Findet: !
\d
Findet alle Ziffern von 0 bis 9.
Sucht Dateinamen, die mit DSC anfangen, gefolgt von vier Ziffern, gefolgt von .tif oder TIF – ein Klassiker der Dateinamen aus Digitalkameras.
Muster: /DSC\d\d\d\d.jpg/gi String: DSC4608.jpg DSC4610.jpg DSC4700.JPG Findet: DSC4608.jpg, DSC4610.ipg, DSC4700.JPG Beispiel: if (/\d+[\.|,]?\d*/.test(num)) ^ ^ ^^ ^ ^ |   | || | | \d+: mindestens eine Ziffer <---+   | || | | | || | | \.: gefolgt von einem Punkt <---+ || | | || | | |: oder <---+| | | | | | ,: einem Komma <---+ | | | | ?: Punkt oder Komma dürfen einmal <---+ | oder keinmal auftreten | | d*: gefolgt von 0 oder mehr Ziffern <---+ test, ob num eine ganze Zahl oder eine Zahl mit einem Dezimalpunkt oder -komma ist
\D
Alle Zeichen, die keine Ziffern sind
Sucht ebenfalls Dateinamen, aber diese Namen von Bilddateien aus der Digitalkamera beginnen mit einem Unterstrich. Gesucht werden TIFF-Dateien:
Muster: /\D{4}\d{4}\.tif/gi String: _DSC4608.tif oder _DSC4610.jpg oder _DSC4700.TIF oder _DSC4610.tif und ein Defekt: _DSC4611?tif Findet: _DSC4608.tif,_DSC4700.TIF,_DSC4610.tif
\b
Wortgrenze
Testet, ob das class-Attribut eines HTML-Tags die Klasse showImg enthält:
Muster: /\bshowImg\b/ String: showImg2 content showImg Findet: liefert einen Treffer zurück
\B
Jede Position, die keine Wortgrenze ist
Muster: /\Bsee/gi String: See, Wannseebad, Nordsee Findet: See, Wannseebad, Nordsee
\s
Alle Whitespace-Zeichen – das sind alle Arten von Leerzeichen vom einfachen „Blank“ über Tabulatoren bis hin zum Zeilenumbruch.
Eliminiert den Weißraum (Leerzeichen, Zeilenumbrücke, Tabulatoren) zwischen HTML-Tags:
Muster: />\s*</g // ersetzen durch >< String: <dt id="jsregSS">\s </dt> <dd>Alle Whitespace-Zeichen ….</dd> <dd>Findet den Weißraum zwischen HTML-Tags: </dd> Ersetzung: <dt id="jsregSS">\s </dt><dd>Alle Whitespace-Zeichen …</dd><dd>Findet den Weißraum zwischen HTML-Tags: </dd>
\S
Alle einzelnen Zeichen, die kein Whitespace sind.
Muster: /\Sa/gi String: Wandern andere „an“ Findet: Wandern andere „an“

Metazeichen

Metazeichen sind einfache Sonderzeichen wie ein Punkt und der senkrechte Strich, die in regulären Ausdrücken eine andere Bedeutung haben als in einem ganz normalen Suchstring.

Damit der reguläre Ausdruck ein Zeichen nicht als Sonderzeichen (hierzu zählen der Begrenzer / und auch der .), sondern als normales Zeichen auffasst, wird dem Zeichen ein umgekehrter Schrägstrich (Backslash) vorangestellt: /\// trifft das erste Vorkommen eines /-Zeichens und /\/\/www/ das erste Vorkommen von //www.

. (Punkt)
findet alle Zeichen. Der Punkt erinnert an den *-Joker bei der Suche nach Dateinamen unter Windows und Mac. Im Gegensatz zu regulären Ausdrücken in Perl oder Grep findet der Punkt kein Zeilenende!
Muster: /./ String: James Bond Findet: J, a, m, e, s, , B, o, n, d String: \n\r Findet: kein Treffer
^ (Caret)
steht für den Anfang eines Strings und darf nicht mit dem Caret-Zeichen verwechselt werden, das in eckigen Klammern eine Negierung bewirkt.
Muster: /^Von/ String: Von 3 bis 4, von 2 bis 5 Findet: Von 3 bis 4, von 2 bis 5
$ (Dollar)
kennzeichnet das Ende eines Strings und kann auch nur am Ende des regulären Ausdrucks vor dem schließenden Schrägstrich stehen.
Muster: /10$/ String: 10 vor 10 Findet: 10 vor 10 Muster: /^Martha$/ String: Unsere Martha Findet: kein Treffer
| (Senkrechter Strich)
Angabe von Alternativen
Muster: /H(ä|ae)(ß|ss)ler/g // Sucht unterschiedliche Schreibweisen String: Ulrike Häßler Ulrike Haessler Ulrike Haeßler Findet: Häßler,Haessler,Haeßler
() (runde Klammern)
Ein Ausdruck in runden Klammern fasst Teile des Suchmusters zusammen und grenzt es von anderen Suchmustern ab. Ausdrücke in runden Klammern bilden Unterausdrücke, die sich später durch sogenannte Backreferences ansprechen lassen.
Muster: /Ann (H|M)/g String: Ann H., Ann M., Ann S. Findet: Ann H., Ann M., Ann S. Muster: /(a|b)(c|d)/ Findet: alle Zeichenketten ac, ad, bc oder bd Muster /(A(b|c)|DEF)/ Findet: alle Zeichenketten Ab, Ac oder DEF
[ ] (eckige Klammern)
grenzt eine Liste von Zeichen an einer bestimmten Position der Zeichenkette weiter ein.
Muster: /S[abc]/g String: Sache, Sinn, Schaden Findet: Sache, Sinn, Schaden

Zeichenklassen

Viereckige Klammern legen eine Zeichenklasse fest. Eine Zeichenklasse steht an ihrer Position im String für eine Gruppe von Zeichen – z.B. legt S[a-h] fest, dass an der Stelle hinter dem S ein Buchstabe von a bis h stehen muss.

Innerhalb der viereckigen Klammern verlieren alle Metazeichen außer dem Circumflex und dem Backslash ihre Bedeutung und müssen nicht maskiert werden. Der Circumflex am Anfang einer Zeichenklasse negiert die Zeichen – S[^a-e] legt fest, dass nach dem großen S kein Buchstabe aus dem Bereich a bis e stehen darf. Steht der Circumflex nicht am Anfang der Zeichenklasse – S[a-e^] – verliert er seine besondere Bedeutung und hier wird nach dem großen S gefolgt von einem Buchstaben von a bis e oder einem Circumflex gesucht.

[xyz]
Findet alle Zeichen innerhalb der eckigen Klammern.
Sucht nach Zeichenketten, die ein D oder ein R an der zweiten Stelle aufweisen
Muster: /<[DR]\w/g | | | \w: Beliebiger Buchstabe <------+ | | | | [DR]: gefolgt von D oder R <------+ | | \w: gefolgt von einem beliebigen Buchstaben <------+ String: ARD, WDR, RTL, PRO7, MDR, BR Findet: ARD,WDR,PRO,MDR
[^xyz]
Der Circumflex innerhalb einer Zeichenklasse grenzt eine Liste von Zeichen an einer bestimmten Position der Zeichenkette aus.
Sucht nach allen Zeichenketten, die mit S beginnen und an der zweiten Stelle kein a, b oder c enthalten:
Muster: /S[^abc]\w*/g | | | | S: Buchstabe S <------+ | | | | | | [^abc]: nicht gefolgt von a, b, oder c <------+ | | | | \w: gefolgt von einem beliebigen Buchstaben <------+ | | *: vorangehendes Zeichen darf beliebig oft vorkommen <------+ String: Sinn, solche Sachen, so ein Schaden, Sonderfall, Sonne und Regen Findet: Sinn,Sonderfall,Sonne
[a-z]
Alle Zeichen von a bis z.
Sucht alle Wörter, die mit T oder t anfangen und einen Bindestrich enthalten können:
Muster: /\bT[a-zß-ü-]*/gi String: Tor T-Shirt Torbögen, der junge Törleß Torwart Torè Toraç Torø Findet: Tor,T-Shirt,Torbögen,Törleß,Torwart,Torè,Toraç,Torø
[0-9]
Alle Ziffern von 0 bis 9
Sucht alle Zahlen am Anfang einer Zeile, die mit 5 anfangen
Muster: /^5[0-9]*/gm || | | || ^: Anfang der Zeichenkette <------+| | | || | | | || 5: Erstes Zeichen ist eine 5 <------+ | | || | | || [0-9]: gefolgt von einer Ziffer von 0 bis 9 <------+ | || | || *: vorangehendes Zeichen darf beliebig oft vorkommen <------+ || || g: im gesamten String <------+| | m: in jeder Zeile <------+ String: 50074 Irgendwo 2700 Zinnsoldaten 59245 Leitzahl 5 oder 5700 Findet: 50074,59245,5
[A-Za-z0-9]
alle Buchstaben und Ziffern, aber keine Umlaute
[a-zß-ü]
alle Kleinbuchstaben und kleinen Umlaute
[A-ZÀ-Ü] sucht nach allen Großbuchstaben und großen Umlauten und erwischt neben den Umlauten der deutschen Sprache auch die groß geschriebenen Ç, É und Õ.

Umlaute haben ein schweres Leben in regulären Ausdrücken. Wunderbarer Weise erwischt ß-ü das ß und alle Umlaute der deutschen Sprache sowie das Accent Egue der Franzosen, die Ligatur æ und ein Cedilla, äquivalent dazu liefert À-Ü die groß geschriebenen Umlaute der westeuropäischen Zeichen.

Replikatoren

Replikatoren legen minimale, maximale oder exakte Anzahlen für ein oder mehrere Zeichen fest. Ohne die Angabe von Replikatoren nimmt der Javascript-Interpreter an, dass ein Zeichen genau einmal vorkommen muss.

{n}
Das vorangestellte Zeichen muss genau n mal vorkommen
Muster: /20{3}/
Treffer: 2000 und 2004
{n,}
Steht für eine Anzahl von mindestens n Zeichen
Muster: /^[0-9]{5}$/ String: 57366 Findet: 57366
{n,m}
Steht für eine Anzahl von mindestens n, aber höchstens m Zeichen.
Muster: /_DSC\d{4}.TIF/i String: _DSC4608.tif _DSC4610.tif _DSC4700.TIF Findet: _DSC4608.tif,_DSC4610.tif,_DSC4700.TIF
?
Das vorangestellte Zeichen darf genau null mal oder einmal in der Zeichenkette vorkommen.
Muster: /\D?\d{6}/g findet in einem Nummerkreis aus sechs Ziffern, in dem Ziffern ein Buchstabe vorangestellt sein kann
Treffer: D100345, 2000, 234567, D18254, 1234
*
Das vorangestellte Zeichen kann 0 mal oder beliebig oft vorkommen. Mit großer Vorsicht zu verwenden: /a*/ trifft auf jeden String zu, denn ein a ist immer drin oder nicht drin.
Muster: /a*/
Treffer: Dunkelheit und Sonnenschein
+
Das vorangestellte Zeichen muss mindestens einmal, kann aber auch mehrmals vorkommen.
Sucht nach allen Tags und ersetzt sie durch einen Leerstring "":
Muster: /<[^<]+</g | | || <: Zeichenkette beginnt mit < <------+ | || | || [^<]: Alle Zeichen außer < <------+ || || +: vorangestelltes Zeichen ([^<]) muss mind. einmal vorkommen <------+| | <: Zeichenkette ende mit < <------+ String: <dl> <dt id="jsregUmlaute">[a-zß-ü]</dt> <dd>alle Kleinbuchstaben und kleinen Umlaute</dd> <dd>[A-ZÀ-Ü] sucht nach allen Großbuchstaben und großen Umlauten</dd> </dl> <p>Umlaute haben ein schweres Leben.</p> Ersetzung: [a-zß-ü] alle Kleinbuchstaben und kleinen Umlaute [A-ZÀ-Ü] sucht nach allen Großbuchstaben und großen Umlauten Umlaute haben ein schweres Leben.
Auf diesselbe Weise werden Hochkommas gesucht: /"[^"]+"/g

Backtracking

Bei der Auswertung eines regulären Ausdrucks liest der Interpreter die Zeichenkette Zeichen für Zeichen ein und vergleicht jedes Zeichen mit der entsprechenden Stelle des regulären Ausdrucks. Dabei merkt sich der Interpreter die Stellen, an denen es mehr als eine Möglichkeit gibt und wenn der Interpreter beim Testen einer Variante feststellt, dass der Gesamtausdruck nicht mehr zutrifft, kehr er an diese Stelle zurück und prüft die Alternative.

Dieses „Backtracking“ erlaubt numerierte Rückbezüge auf geklammerte Ausdrücke. Alle Ausdrücke in runden Klammern bilden Gruppen, die von links nach rechts durchnummeriert werden. 

(Meier)|(H(ä|ae)(ß|ss)ler)
0 -> Meier
1 -> Häßler
2 -> äß
3 -> äss
4 -> aeß
5 -> aess

Susanne Schmidt: Reguläre Ausdrücke in Perl

Using Regular Expressions with JavaScript and ECMAScript

RegExp-Tutorial

   


Copyright © 2000 - 2010 Media Engineering Alle Rechte vorbehalten
Design + Programmierung Media Engineering U. Häßler 47506 Neukirchen-Vluyn • Impressum und Nutzungsbestimmungen