Reguläre Ausdrücke

  • Adressname der Version: JavaScript/Guide/Regular_Expressions
  • Titel der Version: Reguläre Ausdrücke
  • ID der Version: 314125
  • Erstellt:
  • Autor: eminor
  • Aktuelle Version? Nein
  • Kommentar

Inhalt der Version

Reguläre Ausdrücke sind Muster, die eingesetzt werden, um Text auf bestimmte Zeichenkombinationen zu überprüfen. Auch reguläre Ausdrücke sind Objekte bei JavaScript. Die Muster werden mit den Methoden exec und test von RegExp und den Methoden match, replace, search und split von String verwendet. Dieses Kapitel beschreibt reguläre Ausdrücke in JavaScript.

Erstellen von regulären Ausdrücken

Ein regulärer Ausdruck kann auf zwei verschiedene Arten erstellt werden.

Zum einen kann ein Literal verwendet werden:

var re = /ab+c/;

Hierbei findet die Komplilierung des regulären Ausdrucks während der Auswertung des Skripts statt. Wenn der reguläre Ausdruck konstant bleibt, sich also nicht ändert, ist diese Vorgehensweise aufgrund der schnelleren Ausführungsgeschwindigkeit empfehlenswert.

Zum anderen kann wie folgt die Konstruktorfunktion des Objekts RegExp zum Einsatz kommen:

var re = new RegExp("ab+c");

Bei der Benutzung der Konstruktorfunktion wird der reguläre Ausdruck während der Laufzeit kompiliert. Sie sollte verwendet werden, wenn man weiß, dass sich das Muster während der Laufzeit ändert oder man das Muster noch nicht kennt und von einer anderen Quelle, wie z.B. der Benutzereingabe, bezieht.

Schreiben von Mustern für reguläre Ausdrücke

Ein Muster eines regulären Ausdrucks wird aus einfachen Zeichen, wie z.B. /abc/ oder einer Kombination von einfachen und speziellen Zeichen, wie z.B. /ab*c/ oder /Kapitel (\d+)\.\d*/ erstellt. Das letzte Beispiel enthält Klammern, die zur Speicherung verwendet werden. Die Übereinstimmung im Text, welche auf das eingeklammerte Muster passt, wird hierbei für die spätere Verwendung hinterlegt, wie unter Benutzung von geklammerten Mustern beschrieben.

Verwendung von einfachen Mustern

Einfache Muster werden aus Zeichen konstruiert, für die man eine direkte Übereinstimmung finden möchte. Zum Beispiel passt das Muster /abc/ nur dann für eine Zeichenkette, wenn exakt die Zeichen 'abc' aufeinanderfolgend in dieser Reihenfolge vorkommen. Solch eine Übereinstimmung kommt z.B. in der Zeichenkette "Hallo, kennst du das abc?" und "Das müssen wir noch abchecken." vor. In beiden Fällen enthält die Zeichenkette die Zeichenfolge "abc". In der Zeichenkette "Stab" gibt es keine Übereinstimmung, weil die Zeichenfolge "abc" darin nich vorkommt.

Verwendung von speziellen Zeichen

Wenn bei der Suche nicht nur nach einer direkten Übereinstimmung, sondern z.B. nach einem oder mehreren aufeinanderfolgenden Vorkommen des Buchstabens "b" oder nach Leerräumen (sowohl Tabulator, Leerzeichen als auch Steuerzeichen) gesucht wird, kommen spezielle Zeichen zum Einsatz. Zum Beispiel stimmt das Muster /ab*c/ mit allen Zeichenkombinationen überein, die ein "a", dann sofort nachfolgend 0 oder mehrere "b" (Das Sternchen bedeutet: 0 oder mehr Vorkommen des vorherigen Zeichens) und anschließend sofort ein "c" enthalten. Demnach wird in der Zeichenfolge "cbbabbbbcdebc" eine Übereinstimmung gefunden, weil das Muster auf die Zeichenfolge "abbbbc" passt.

Die folgende Tabelle zeigt eine komplette Liste der speziellen Zeichen, die in regulären Ausdrücken verwendet werden, mit einer Beschreibung zu deren Bedeutung.

Tabelle 4.1 Spezielle Zeichen in regulären Ausdrücken
Character Meaning
\ Eine der folgenden Bedeutungen:
  • Für Zeichen, die normalerweise buchstäblich interpretiert werden, wird mit der Voranstellung des Rückstrichs dafür gesorgt, dass das Zeichen als speziell und nicht als normales Zeichen interpretiert wird. Zum Beispiel stimmt /b/ mit dem Zeichen "b" überein. Stellt man dem "b" einen Rückstrich voran, also /\b/, wird das Zeichen als spezielles Zeichen - in diesem Fall als Wortgrenze - gedeutet.
  • Bei Zeichen, die normalerweise sofort als spezielle Zeichen interpretiert werden, bewirkt der Rückstrich genau das Gegenteil, d.h. dem Zeichen wird die spezielle Bedeutung genommen und es wird als einfaches Zeichen interpretiert. Zum Beispiel ist das Zeichen * (Sternchen) ein spezielles Zeichen mit der Bedeutung: 0 oder mehr Vorkommen des vorherigen Zeichens. Der Ausdruck /a*/ steht demnach für 0 oder mehr a's. Um dem Zeichen * (Sternchen) die spezielle Bedeutung zu nehmen, stellt man ihm einen Rückstrich voran, z.B. stimmt /a\*/ mit 'a*' überein - der Stern wird nun als einfaches Zeichen interpretiert.
  • Das Maskieren eines Zeichens durch die Voranstellung eines Rückstrichs wird auch als escapen bezeichnet. Außerdem sollte man sich merken, dass bei Verwendung der new RegExp("pattern")-Notation auch der Rüchstrich selbst eine spezielle Bedeutung hat und maskiert werden muss, wenn er als normales Zeichen interpretiert werden soll.
^

Das Zirkumflex-Zeichen steht für den Anfang der Eingabe. Wenn das Flag für mehrere Zeilen (multiline flag) auf true gesetzt wurde, wird auch eine Übereinstimmung direkt hinter dem Zeichen für einen Zeilenumbruch (\n) gefunden.

Der Ausdruck /^A/ passt zwar auf das "A" in "Apfel", nicht  jedoch auf das "A" in "Ein Apfel", weil das "A" bei letzterer Zeichenkette nicht am Anfang steht.

Achtung: Wenn das Zeichen innerhalb von eckigen Klammern (einer Zeichenauswahl) steht, hat es eine andere Bedeutung (siehe [^xyz] in dieser Tabelle).

Zum Beispiel stimmt /[^a-zA-Z\s]/ mit der "3" in "Ich habe 3 Schwestern" überein. Die eckigen Klammern kennzeichnen die Zeichenauswahl. Das Zirkumflex innerhalb dieser Klammern negiert die aufgezählten Zeichen: nicht a bis z, nicht A bis Z und keine Leerräume wie das Leerzeichen oder die Steuerzeichen; übrig bleibt allein die "3".

$

Das Dollarzeichen steht für das Ende der Eingabe. Wenn das Flag für mehrere Zeilen (multiline flag) auf true gesetzt ist, wird auch eine Übereinstimmung direkt hinter dem Zeichen für einen Zeilenumbruch (\n) gefunden.

Zum Beispiel wird mit /t$/ bei "Butter" keine Übereinstimmung gefunden, jedoch bei "Brot", weil das "t" am Ende steht.

*

Das Sternchen steht für eine beliebige Anzahl des vorangestellten Zeichens, also 0-mal oder öfter. Das Zeichen muss also nicht unbedingt vorkommen, sondern darf auch einfach nicht vorhanden sein. Das Sternchen wird gerne in Kombination mit dem . (Punkt) als Platzhalter für "ein beliebiges Zeichen beliebig oft" verwendet.

Der Ausdruck /bu*/ passt auf "buuuuu" in "Ein Geist buuuuuht" als auch auf "b"  in "Ein Blauwal blubbert", jedoch nicht auf "Eine Katze kratzt".

+

Steht für das vorangestellte Zeichen einmal oder öfter und ist equivalent zu {1,}. Das Zeichen muss für einen Treffer also mindestens einmal vorkommen.

Zum Beispiel passt /a+/ auf "a" in "Schokolade" und alle a's in "Schokolaaaade".

?

Steht für das vorangestellte Zeichen 0 oder einmal und ist equivalent zu {0,1}.

Zum Beispiewird passt /e?le?/ sowohl auf "el" in "Engel", als auch auf "le" in "Kapelle" und auch "l" in "Oslo".

Wenn es sofort hinter einen der Quantoren *, +, ?, oder {} gestellt wird, deaktiviert es die standardmäßige  "Gierigkeit" (eine möglichst hohe Anzahl von passende Zeichen einschließend) dieser Quantoren und macht sie "genügsam" (eine möglichst geringe Anzahl von passende Zeichen einschließend).

Zum Beispiel passt der Ausdruck /\d+/ nicht-global auf die Zeichenkette "123abc" angewendet auf "123", weil der Quantor + (Pluszeichen) "gierig" ist. Der Ausdruck /\d+?/ steht hingegen nur für "1", weil der Quantor + (Pluszeichen) aufgrund der Beeinflussung durch das hintangestellte ? (Fragezeichen) "genügsam" ist.

Das Fragezeichen wird auch bei sogenannten lookahead assertions (vorausschauenden Annahmen/Behauptungen) eingesetzt, die in dieser Tabelle unter x(?=y) und x(?!y) beschrieben sind.

.

Der Punkt steht für ein einzelnes Zeichen mit Ausnahme des Zeichens für den Zeilenumbruch.

Zum Beispiel passt /.n/ auf "in" und "än" in der Zeichenkette "nur ein Apfel hängt am Baum", jedoch nicht auf das "n" ganz am Anfang.

(x)

Steht für "x", also die eingeklammerten Zeichen. Die passenden Zeichen des Musters innerhalb der Klammern werden gespeichert, damit sie an anderer Stelle wieder eingesetzt werden können. Die Klammern werden auch "capturing parentheses" (aufnehmende Klammern) genannt.

Zum Beispiel steht /(foo)/ für "foo" in "foobar" und gleichzeitig wird "foo" gespeichert. Die passenden Zeichen können durch Array-Elemente wieder eingesetzt werden. Dabei steht [1] für die Zeichen des ersten Klammerpaars, [2] für die Zeichen des zweiten Paars usw.

(?:x) Steht für  "x", aber die Übereinstimmung wird nicht gespeichert. Diese Klammern werden auch als "non-capturing parentheses" bezeichnet. Die übereinstimmenden Zeichen können nicht wieder eingesetzt werden und die Array-Elemente [1], ..., [n] finden keine Anwendung.
x(?=y)

Steht für "x", jedoch nur wenn "x" vor "y" steht. Dies wird als lookahead (Vorausschauen) bezeichnet.

Zum Beispiel passt /Jack(?=Sprat)/ auf "Jack" nur dann, wenn "Sprat" dahinter steht. Der Ausdruck /Jack(?=Sprat|Frost)/ passt auf "Jack" nur dann, wenn dahinter "Sprat" oder "Frost" steht. Doch weder "Sprat" noch "Frost" ist Teil des übereinstimmenden Ergenisses.

x(?!y)

Passt nur dann auf "x", wenn "x" nicht vor "y" steht. Dies wird auch als negated lookahead (negierte vorausschauende Annahmen) bezeichnet.

Zum Beispiel passt /\d+(?!\.)/ nur dann auf eine Nummer, wenn diese nicht vor einem Dezimalpunkt steht. Der reguläre Ausdruck /\d+(?!\.)/.exec("3.141")  passt auf "141", jedoch nicht auf "3.141".

x|y

Passt auf entweder "x" oder "y".

Zum Beispiel passt der Ausdruck /grüner|roter/  auf "grüner" in "grüner Apfel" und "roter" in "roter Apfel".

{n}

Das n steht für eine postive ganze Zahl. Das Muster passt exakt auf die Anzahl n des vorangestellten Zeichens.

Zum Beispiel passt /a{2}/ nicht auf das "a" in "Schokolade",  jedoch auf alle a's in "Schokolaade" und die ersten beiden a's in "Schokolaaade".

{n,m}

Wobei n und m positive ganze Zahlen sind. Passt auf mindests n und höchstens m Vorkommen des vorangestellten Zeichens. Wenn für n oder m eine 0 stehen soll, kann sie auch weggelassen werden.

Zum Beispiel passt /a{1,3}/ auf nichts in "cndy", jedoch auf das "a" in "candy", die beiden a's in "caandy," und die ersten drei a's in "caaaaaaandy".  Merke: Wenn der Ausdruck auf "caaaaaaandy" angewendet wird, ist die Übereinstimmung "aaa", auch wenn in der Zeichenkette mehr a's enthalten sind.

[xyz]

Die eckigen Klammern kennzeichnen eine Zeichenauswahl. Der Ausdruck stimmt mit allen in den Klammern stehenden Zeichen überein. Mit Hilfe eines Bidestrichs kann ein Bereich (von a bis z) festgelegt werden. Spezielle Zeichen (wie der Punkt (.) oder das Sternchen (*)) haben keine spezielle Bedeutung innerhalb der eckigen Klammern. Sie müssen nicht "escaped" werden. Escape-Sequenzen funktionieren also auch.

Zum Beispiel ist [abcd] dasselbe wie [a-d]. Beides passt auf das "b" in "biegen" und das "d" in "denken". Die Ausdrücke /[a-z.]+/ und /[\w.]+/ passen beide auf "test.i.ng".

[^xyz]

Eine negierte oder komplementäre Zeichenauswahl. Das Zirkumflex-Zeichen an erster Stelle in den Klammern negiert die Zeichenauswahl. Der Ausdruck passt also auf alle Zeichen, die nicht in den Klammern stehen. Es kann mit Hilfe eines Bindestrichs auch ein Bereich von Zeichen spezifiziert werden. Alle Zeichen, die bei einer normalen Zeichenauswahl funktionieren, funktionieren hier ebenso.

Zum Beispiel ist [^abc] dasselbe wie [^a-c]. Beide Ausdrücke passen auf das "r" in "brechen" und das "m" in "campen".

[\b] Passt auf das Steuerzeichen für die Backspace-Taste (U+0008). (Sollte nicht mit \ b verwechselt werden.)
\b

Steht für eine Wortgrenze. Wortgrenzen sind an den Stellen, wo kein anderes Wortzeichen vor oder hinter einem Wortzeichen steht. Eine Wortgrenze wird nicht in die Übereinstimmung aufgenommen. Mit anderen Worten ist die Länge einer Wortgrenze gleich 0 - die Wortgrenze ist der Zwischenraum zwischen einem Wortzeichen und einem Zeichen, das kein Wortzeichen ist oder zwischen einem Wortzeichen und dem Anfang oder Ende der Eingabe. (Sollte nicht mit [\b] verwechselt werden.)

Beispiele:
/\bMon/ passt auf das "Mon" in "Mond" ;
/ll\b/ passt nicht auf "ll" in "Falle", weil "ll" nicht vor einer Wortgrenze steht, sondern vor dem Zeichen "e", wobei es sich um ein Wortzeichen handelt.
/ond\b/ passt auf das "ond" in "Mond", weil "ond"  das Ende der Zeichenkette ist, also nicht vor einem Wortzeichen steht.
Bei /\w\b\w/ wird niemals eine Übereinstimmung gefunden, weil eine Wortgrenze niemals gleichzeitig vor einem Wortzeichen und keinem Wortzeichen stehen kann.

\B

Steht für alle Zeichen, die keine Wortgrenze sind. Dies trifft auf Positionen zu, wo zwei nebeneinanderstehende Zeichen vom selben Typ sind: Entweder sind beide Wortzeichen oder keine Wortzeichen. Der Anfang und das Ende einer Zeichenkette werden nicht als Wortzeichen angesehen, gelten also als Wortgrenzen.

Zum Beispiel passt /\B../ auf "oo" in "noonday" und /y\B./ auf "ye" in "possibly yesterday."

\cX

X ist ein Zeichenbereich von A bis Z. Passt auf ein Steuerzeichen in einer Zeichkette.

Zum Beispiel steht /\cM/ für das Steuerzeichen control-M (U+000D) in einer Zeichenkette.

\d

Steht für Ziffern und ist equivalent zu [0-9].

Zum Beispiel passt /\d/ oder /[0-9]/ auf "2" in "B2 ist die Zimmernummer."

\D

Steht für alle nicht-Ziffern und ist equivalent zu [^0-9].

Zum Beispiel passt /\D/ oder /[^0-9]/ auf "B" in "B2 ist die Zimmernummer."

\f Steht für einen Seitenvorschub (engl. form feed (U+000C)).
\n Steht für einen Zeilenbruch (engl. line feed bzw. new line U+000A).
\r Steht für einen Waagenrücklauf (engl. carriage return (U+000D).
\s

Steht für ein einzelnes Leerraum-Zeichen, einschließlich Leertaste, Tabulator, Seitenvorschub und Zeilenumbruch und ist equivalent zu [ \f\n\r\t\v​\u00A0\u1680​\u180e\u2000​\u2001\u2002​\u2003\u2004​ \u2005\u2006​\u2007\u2008​\u2009\u200a​\u2028\u2029​\u2028\u2029​ \u202f\u205f​\u3000].

Zum Beispiel passt /\s\w*/ auf "bar" in "foo bar".

\S

Steht für ein einzelnes Zeichen, das kein Leerraum-Zeichen ist. Equivalent zu [^ \f\n\r\t\v​\u00A0\u1680​\u180e\u2000​\u2001\u2002​\u2003\u2004​ \u2005\u2006​\u2007\u2008​\u2009\u200a​\u2028\u2029​\u2028\u2029​ \u202f\u205f​\u3000].

Zum Beispiel passt /\S\w*/ auf "foo" in "foo bar".

\t Steht für einen Tabulator (engl. horizontal tab U+0009).
\v Steht für einen vertikalen Tabulator (engl. vertical tabulator (U+000B).
\w

Steht für ein alphanumerisches Zeichen (Wortzeichen), einschließlich Unterstrich. Equivalent zu [A-Za-z0-9_].

Zum Biespiel passt /\w/ auf "a" in "apple" als auch auf "5" in "$5.28" und "3" in "3D".

\W

Steht für ein nicht-alphanumerisches Zeichen (nicht-Wortzeichen). Equivalent zu [^A-Za-z0-9_].

Zum Beispiel passt /\W/ oder /[^A-Za-z0-9_]/ auf "%" in "50%".

\n

Stellt einen Rückgriff auf die passenden Zeichen eines eingeklammerten Teilausdrucks dar, wobei n eine positive ganze Zahl ist. Die Zahl steht hierbei für das jeweilge Teilmuster innerhalb eines Klammerpaars an entsprechender Stelle (öffnende Klammern werden gezählt).

Zum Beispiel passt /Apfel(,)\sOrange\1/ auf "Apfel, Orange," in "Apfel, Orange, Kirsche, Pfirsich".

\0 Steht für ein NULL-Zeichen (U+0000). Es sollte kein Ziffer dahinter stehen, weil \0<Ziffer> eine Escape-Sequenz für oktale Zahlen ist.
\xhh Steht für das Zeichen mit dem Code hh (zweistellige hexadezimale Zahl).
\uhhhh Steht für das Zeichen mit dem Code hhhh (vierstellige hexadezimale Zahl).

Benutzung von Klammern

Klammern werden verwendet, um den eingeklammerten Teil des regulären Ausdrucks zu speichern. Einmal gespeichert kann dieser Teil an anderer Stelle wieder eingesetzt werden, wie unter Benutzung von geklammerten Mustern beschrieben.

Zum Beispiel beinhaltet der Ausdruck /Kapitel (\d+)\.\d*/ einige maskierte und spezielle Zeichen. Mit den Klammern wird bewirkt, dass die Zeichen, welche mit dem eingeklammerten Muster übereinstimmen, gespeicert werden. Der Ausdruck stimmt genau mit der Zeichenkette "Kapitel " gefolgt von einer oder mehreren Ziffern (\d steht für eine Ziffer und das + (Pluszeichen) bedeutet 1 oder mehr Vorkommen), einem Punkt (der Punkt selbst ist standardmäßig ein spezielles Zeichen, weshalb er maskiert werden muss) und nochmal beliebig vielen Ziffern (\d steht für eine Ziffer und der Stern bedeutet 0 oder mehr Vorkommen) überein. Zusätzlich werden die Klammern eingesetzt, um die erste Ziffer zu speichern.

Eine Übereinstimmung wird z.B. in "Offenes Kapitel 4.3, Absatz 6" gefunden und dabei wird "4" gespeichert. Auf die Zeichenkette "Kapitel 3 und 4" passt der Ausdruck nicht, weil hinter der ersten Ziffer "3" kein Punkt steht.

Möchte man einen zusammenhängenden Teil einer Zeichenkette suchen, jedoch nicht speichern, setzt man ?: an den Anfang innerhalb der Klammern. Zum Beispiel stimmt (?:\d+) mit einer oder mehr Ziffern überein, aber diese Ziffern werden nicht gespeichert.

Arbeiten mit regulären Ausdrücken

Reguläre Ausdrücke werden mit den Methoden exec und test von RegExp und den Methoden match, replace, search und split von String verwendet. Diese Methoden sind in der JavaScript Referenz beschrieben.

Table 4.2 Methoden die reguläre Ausdrücke verwenden
Method Description
exec Eine Methode von RegExp, die eine Suche nach einer Übereinstimmung in einer Zeichenkette durchführt. Sie gibt ein Array mit den Übereinstimmungen zurück.
test Eine Methode von RegExp, die eine Zeichenkette auf eine Übereinstimmung überprüft. Sie gibt true oder false zurück.
match Eine Methode von String, die eine Suche nach einer Übereinstimmung in einer Zeichenkette durchführt. Sie gibt ein Array zurück oder null bei keinem Treffer.
search Eine Methode von String, die eine Zeichenkette auf eine Übereinstimmung überprüft. Sie gibt den Index der Übereinstimmung zurück oder -1 bei keinem Treffer.
replace Eine Methode von String, die eine Suche nach einer Übereinstimmung in einer Zeichenkette durchführt und die Übereinstimmungen durch eine andere Zeichenkette ersetzt.
split Eine Methode von String, die anhand eines regulären Ausdrucks oder einer festen Zeichkette eine Zeichenkette trennt und die Teile als Array zurückgibt.

Wenn man nur wissen möchte, ob ein regulärer Ausdruck auf eine Zeichenkette passt, sollten die Methoden test oder search zum Einsatz kommen. Möchte man mehr erfahren, sollte man auf die Methoden exec oder match zurückgreifen (langsamere Ausführsgeschwindigkeit). Die Methoden exec und match geben ein Array zurück falls Übereinstimmungen gefunden werden und updaten die Eigenschaften des zugehörigen RegExp-Objekts und des vordefinierten RegExp-Objekts. Wenn keine Übereinstimmungen gefunden werden, geben die Methoden null (konvertiert: false) zurück.

Bei fogendem Beispiel kommt die Methode exec zum Einsatz, um eine Übereinstimmung in einer Zeichnkette zu finden.  

var myRe = /d(b+)d/g;
var myArray = myRe.exec("cdbbdbsbz");

Wenn man auf die Eingenschaften des Objekts für den regulären Ausdruck nicht zugreifen möchte, kann man myArray auch direkt wie folgt erzeugen:

var myArray = /d(b+)d/g.exec("cdbbdbsbz");

Möchte man den regulären Ausdruck aus einem String erzeugen, besteht folgende Möglichkeit:

var myRe = new RegExp("d(b+)d", "g");
var myArray = myRe.exec("cdbbdbsbz");

Bei diesen Skripten werden Übereinstimmungen gefunden. Es wird ein Array zurückgegeben und die Eigenschaften geupdatet, welche in der nachstehenden Tabelle aufgelistet sind.

Tabelle 4.3 Ergebnisse von regulären Ausdrücken
Objekt Eigenschaft oder Index Beschreibung Bei diesem Beispiel
myArray   Die übereinstimmende Zeichenfolge und alle gespeicherten Teile. ["dbbd", "bb"]
index Der mit 0 beginnende Index der Übereinstimmung in der Eingabe-Zeichenkette. 1
input Die ursprüngliche Eingabe-Zeichenkette. "cdbbdbsbz"
[0] Die zuletzt übereinstimmenden Zeichen. "dbbd"
myRe lastIndex Der Index bei dem die nächste Suche nach einer Übereinstimmung gestartet wird.  (Diese Eigenschaft wird nur gesetzt, wenn im regulären Ausdruck die Option "g" verwendet wird, wie unter {{ web.link("#Advanced_Searching_With_Flags", "Advanced Searching With Flags") }} beschrieben). 5
source Der Text des Musters - wird geupdatet wenn der reguläre Ausdruck erstellt wird, nicht bei der Ausführung. "d(b+)d"

Wie das zweite Beispiel zeigt, kann man einen regulären Ausdruck einsetzen, der über einen Objekt-intializer erstellt wurde, ohne die Zuweisung einer Variablen. Bei dieser Vorgehensweise ist jede Übereinstimmung ein neuer Ausdruck. Aus diesem Grund kann nicht auf die Eigenschaften dieses regulären Ausdrucks zugegriffen werden. Angenommen man hat z.B. dieses Skript:

var myRe = /d(b+)d/g;
var myArray = myRe.exec("cdbbdbsbz");
console.log("Der Wert von lastIndex ist " + myRe.lastIndex);

Dann ist die Ausgabe:

Der Wert von lastIndex ist 5

Hat man nun aber dieses Skript:

var myArray = /d(b+)d/g.exec("cdbbdbsbz");
console.log("Der Wert von lastIndex ist " + /d(b+)d/g.lastIndex);

Dann ist die Ausgabe:

Der Wert von lastIndex ist 0

Die einzelnen Vorkommen der Zeichenfolgen, die mit /d(b+)d/g übereinstimmen sind bei den beiden Anweisungen verschiedene Objekte und haben dementstrechend auch verschiedene Werte bei der jeweiligen Eigenschaft lastIndex. Falls man auf die Eigenschaften eines Objekts eines regulärenAusdrucks zugreifen möchte, sollte man diesen vorher einer Variablen zuweisen.

Benutzung von geklammerten Mustern

Klammern werden verwendet, um einen Teil der Zeichen, die mit dem regulären Ausdruck übereinstimmen, zu speichern. Zum Beispiel stimmt /a(b)c/ mit der Zeichenfolge "abc" überein und "b" wird gespeichert. Um die gespiecherten Zeichen wieder abzurufen, verwendet man die Array-Elemente [1], ..., [n].

Die Anzahl der möglichen speicherbaren Teile ist nicht limitiert. Das Array, welches zurückgegeben wird, enthält alle gespeicherten Übereinstimmungen. Die folgenden Beispiele zeigen auf, wie man geklammerte Muster einsetzt.

Beispiel 1

Das folgende Skript benutzt die Methode replace(), um Wörter in einer Zeichenkette auszutauschen. Die beiden Muster für die Wörter (\w+) wurden geklammert, damit die Wörter gespeichert werden. Anschließend werden im Ersetzungstext diese gespeicherten Wörter mit $1 und $2 wieder eingesetzt.

var re = /(\w+)\s(\w+)/;
var str = "Jonas Schmidt";
var newstr = str.replace(re, "$2, $1");
console.log(newstr);

Die Ausgabe ist "Schmidt, Jonas".

Erweiterte Suche mit Optionen (Flags)

Reguläre Ausdrücke kennen vier verschiedene Optionen (Flags), die es z. B. erlauben global nach Übereinstimmungen zu suchen oder die Berücksichtigung der Groß- und Kleinschreibweise zu deaktivieren. Zur Aktivierung der globalen Suche wird das Flag g eingesetzt. Die Berücksichtigung der Groß- und Kleinschreibweise (engl. case-insensitive) wird mit dem Flag i abgeschaltet. Die mehrzeilige Suche (engl. multiline) wird mit dem Flag m aktiviert und eine "sticky" Suche, wobei die Übereinstimmung an der aktuellen Postion im Eingabe-Zeichenkette zutreffen muss, wird mit dem Flag y aktiviert. Diese Optionen können getrennt oder gemeinsam verwendet und in beliebiger Reihenfolge angegeben werden. Die Buchsaben werden durch / getrennt an den regulären Ausdruck angehängt.

{{ Fx_minversion_note(3, "Die Unterstützung für das Flag y wurde bei Firefox 3 hinzugefügt. Wenn y aktiviert ist, schlägt die Suche fehl, wenn es keine Übereinstimmung an der aktuellen Position innerhalb der Eingabe-Zeichenkette gibt.") }}

Syntax für die Verwendung von Optionen:

var re = /Muster/Optionen;

oder

var re = new RegExp("Muster", "Optionen");

Die Optionen sind ein integraler Bestandteil des regulären Ausdrucks. Sie können nicht im Nachhinein entfernt oder hinzugefügt werden.

For example, re = /\w+\s/g creates a regular expression that looks for one or more characters followed by a space, and it looks for this combination throughout the string.

var re = /\w+\s/g;
var str = "fee fi fo fum";
var myArray = str.match(re);
console.log(myArray);

This displays ["fee ", "fi ", "fo "]. In this example, you could replace the line:

var re = /\w+\s/g;

with:

var re = new RegExp("\\w+\\s", "g");

and get the same result.

The m flag is used to specify that a multiline input string should be treated as multiple lines. If the m flag is used, ^ and $ match at the start or end of any line within the input string instead of the start or end of the entire string.

Examples

The following examples show some uses of regular expressions.

Changing the Order in an Input String

The following example illustrates the formation of regular expressions and the use of string.split() and string.replace(). It cleans a roughly formatted input string containing names (first name first) separated by blanks, tabs and exactly one semicolon. Finally, it reverses the name order (last name first) and sorts the list.

// The name string contains multiple spaces and tabs,
// and may have multiple spaces between first and last names.
var names = "Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ; Chris Hand ";

var output = ["---------- Original String\n", names + "\n"];

// Prepare two regular expression patterns and array storage.
// Split the string into array elements.

// pattern: possible white space then semicolon then possible white space
var pattern = /\s*;\s*/;

// Break the string into pieces separated by the pattern above and
// store the pieces in an array called nameList
var nameList = names.split(pattern);

// new pattern: one or more characters then spaces then characters.
// Use parentheses to "memorize" portions of the pattern.
// The memorized portions are referred to later.
pattern = /(\w+)\s+(\w+)/;

// New array for holding names being processed.
var bySurnameList = [];

// Display the name array and populate the new array
// with comma-separated names, last first.
//
// The replace method removes anything matching the pattern
// and replaces it with the memorized string—second memorized portion
// followed by comma space followed by first memorized portion.
//
// The variables $1 and $2 refer to the portions
// memorized while matching the pattern.

output.push("---------- After Split by Regular Expression");

var i, len;
for (i = 0, len = nameList.length; i < len; i++){
  output.push(nameList[i]);
  bySurnameList[i] = nameList[i].replace(pattern, "$2, $1");
}

// Display the new array.
output.push("---------- Names Reversed");
for (i = 0, len = bySurnameList.length; i < len; i++){
  output.push(bySurnameList[i]);
}

// Sort by last name, then display the sorted array.
bySurnameList.sort();
output.push("---------- Sorted");
for (i = 0, len = bySurnameList.length; i < len; i++){
  output.push(bySurnameList[i]);
}

output.push("---------- End");

console.log(output.join("\n"));

Using Special Characters to Verify Input

In the following example, the user is expected to enter a phone number. When the user presses the "Check" button, the script checks the validity of the number. If the number is valid (matches the character sequence specified by the regular expression), the script shows a message thanking the user and confirming the number. If the number is invalid, the script informs the user that the phone number is not valid at all.

The regular expression looks for zero or one open parenthesis \(?, followed by three digits \d{3}, followed by zero or one close parenthesis \)?, followed by one dash, forward slash, or decimal point and when found, remember the character ([-\/\.]), followed by three digits \d{3}, followed by the remembered match of a dash, forward slash, or decimal point \1, followed by four digits \d{4}.

The Change event activated when the user presses Enter sets the value of RegExp.input.

<!DOCTYPE html>
<html>  
  <head>  
    <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">  
    <meta http-equiv="Content-Script-Type" content="text/javascript">  
    <script type="text/javascript">  
      var re = /\(?\d{3}\)?([-\/\.])\d{3}\1\d{4}/;  
      function testInfo(phoneInput){  
        var OK = re.exec(phoneInput.value);  
        if (!OK)  
          window.alert(RegExp.input + " isn't a phone number with area code!");  
        else
          window.alert("Thanks, your phone number is " + OK[0]);  
      }  
    </script>  
  </head>  
  <body>  
    <p>Enter your phone number (with area code) and then click "Check".
        <br>The expected format is like ###-###-####.</p>
    <form action="#">  
      <input id="phone"><button onclick="testInfo(document.getElementById('phone'));">Check</button>
    </form>  
  </body>  
</html>

 

Quelltext der Version

<p>Reguläre Ausdrücke sind Muster, die eingesetzt werden, um Text auf bestimmte Zeichenkombinationen zu überprüfen. Auch reguläre Ausdrücke sind Objekte bei JavaScript. Die Muster werden mit den Methoden <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/RegExp/exec" title="exec"><code>exec</code></a> und <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/RegExp/test" title="test"><code>test</code></a> von <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/RegExp" title="RegExp"><code>RegExp</code></a> und den Methoden <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/match" title="match"><code>match</code></a>, <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/replace" title="en-US/docs/JavaScript/Reference/Global_Objects/String/replace"><code>replace</code></a>,<a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/search" title="search"> <code>search</code></a> und <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/split" title="split"><code>split</code></a> von <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String" title="String"><code>String</code></a> verwendet. Dieses Kapitel beschreibt reguläre Ausdrücke in JavaScript.</p>
<h2 id="Erstellen_von_regul.C3.A4ren_Ausdr.C3.BCcken">Erstellen von regulären Ausdrücken</h2>
<p>Ein regulärer Ausdruck kann auf zwei verschiedene Arten erstellt werden.</p>
<p>Zum einen kann ein Literal verwendet werden:</p>
<pre class="brush:js;">
var re = /ab+c/;</pre>
<p>Hierbei findet die Komplilierung des regulären Ausdrucks während der Auswertung des Skripts statt. Wenn der reguläre Ausdruck konstant bleibt, sich also nicht ändert, ist diese Vorgehensweise aufgrund der schnelleren Ausführungsgeschwindigkeit empfehlenswert.</p>
<p>Zum anderen kann wie folgt die Konstruktorfunktion des Objekts <code><a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/RegExp" title="en-US/docs/JavaScript/Reference/Global Objects/RegExp">RegExp</a></code> zum Einsatz kommen:</p>
<pre class="brush:js;">
var re = new RegExp("ab+c");</pre>
<p>Bei der Benutzung der Konstruktorfunktion wird der reguläre Ausdruck während der Laufzeit kompiliert. Sie sollte verwendet werden, wenn man weiß, dass sich das Muster während der Laufzeit ändert oder man das Muster noch nicht kennt und von einer anderen Quelle, wie z.B. der Benutzereingabe, bezieht.</p>
<h2 id="Schreiben_von_Mustern_f.C3.BCr_regul.C3.A4re_Ausdr.C3.BCcke">Schreiben von Mustern für reguläre Ausdrücke</h2>
<p>Ein Muster eines regulären Ausdrucks wird aus einfachen Zeichen, wie z.B. /abc/ oder einer Kombination von einfachen und speziellen Zeichen, wie z.B. /ab*c/ oder /Kapitel (\d+)\.\d*/ erstellt. Das letzte Beispiel enthält Klammern, die zur Speicherung verwendet werden. Die Übereinstimmung im Text, welche auf das eingeklammerte Muster passt, wird hierbei für die spätere Verwendung hinterlegt, wie unter <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Guide/Regular_Expressions#Using_Parenthesized_Substring_Matches">Benutzung von geklammerten Mustern</a> beschrieben.</p>
<h3 id="Verwendung_von_einfachen_Mustern">Verwendung von einfachen Mustern</h3>
<p>Einfache Muster werden aus Zeichen konstruiert, für die man eine direkte Übereinstimmung finden möchte. Zum Beispiel passt das Muster /abc/ nur dann für eine Zeichenkette, wenn exakt die Zeichen 'abc' aufeinanderfolgend in dieser Reihenfolge vorkommen. Solch eine Übereinstimmung kommt z.B. in der Zeichenkette "Hallo, kennst du das abc?" und "Das müssen wir noch abchecken." vor. In beiden Fällen enthält die Zeichenkette die Zeichenfolge "abc". In der Zeichenkette "Stab" gibt es keine Übereinstimmung, weil die Zeichenfolge "abc" darin nich vorkommt.</p>
<h3 id="Verwendung_von_speziellen_Zeichen">Verwendung von speziellen Zeichen</h3>
<p>Wenn bei der Suche nicht nur nach einer direkten Übereinstimmung, sondern z.B. nach einem oder mehreren aufeinanderfolgenden Vorkommen des Buchstabens "b" oder nach Leerräumen (sowohl Tabulator, Leerzeichen als auch Steuerzeichen) gesucht wird, kommen spezielle Zeichen zum Einsatz. Zum Beispiel stimmt das Muster /ab*c/ mit allen Zeichenkombinationen überein, die ein "a", dann sofort nachfolgend 0 oder mehrere "b" (Das Sternchen bedeutet: 0 oder mehr Vorkommen des vorherigen Zeichens) und anschließend sofort ein "c" enthalten. Demnach wird in der Zeichenfolge "cbbabbbbcdebc" eine Übereinstimmung gefunden, weil das Muster auf die Zeichenfolge "abbbbc" passt.</p>
<p>Die folgende Tabelle zeigt eine komplette Liste der speziellen Zeichen, die in regulären Ausdrücken verwendet werden, mit einer Beschreibung zu deren Bedeutung.</p>
<table class="fullwidth-table">
  <caption style="text-align: left">
    Tabelle 4.1 Spezielle Zeichen in regulären Ausdrücken</caption>
  <thead>
    <tr>
      <th scope="col">Character</th>
      <th scope="col">Meaning</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-backslash" id="special-backslash" name="special-backslash"><code>\</code></a></td>
      <td>Eine der folgenden Bedeutungen:<br />
        <ul>
          <li>Für Zeichen, die normalerweise buchstäblich interpretiert werden, wird mit der Voranstellung des Rückstrichs dafür gesorgt, dass das Zeichen als speziell und nicht als normales Zeichen interpretiert wird. Zum Beispiel stimmt <code>/b/</code> mit dem Zeichen "b" überein. Stellt man dem "b" einen Rückstrich voran, also <code>/\b/</code>, wird das Zeichen als spezielles Zeichen - in diesem Fall als Wortgrenze - gedeutet.</li>
          <li>Bei Zeichen, die normalerweise sofort als spezielle Zeichen interpretiert werden, bewirkt der Rückstrich genau das Gegenteil, d.h. dem Zeichen wird die spezielle Bedeutung genommen und es wird als einfaches Zeichen interpretiert. Zum Beispiel ist das Zeichen * (Sternchen) ein spezielles Zeichen mit der Bedeutung: 0 oder mehr Vorkommen des vorherigen Zeichens. Der Ausdruck /a*/ steht demnach für 0 oder mehr a's. Um dem Zeichen * (Sternchen) die spezielle Bedeutung zu nehmen, stellt man ihm einen Rückstrich voran, z.B. stimmt /a\*/ mit 'a*' überein - der Stern wird nun als einfaches Zeichen interpretiert.</li>
          <li>Das Maskieren eines Zeichens durch die Voranstellung eines Rückstrichs wird auch als <em>escapen</em> bezeichnet. Außerdem sollte man sich merken, dass bei Verwendung der new RegExp("pattern")-Notation auch der Rüchstrich selbst eine spezielle Bedeutung hat und maskiert werden muss, wenn er als normales Zeichen interpretiert werden soll.</li>
        </ul>
      </td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-caret" id="special-caret" name="special-caret"><code>^</code></a></td>
      <td>
        <p>Das Zirkumflex-Zeichen steht für den Anfang der Eingabe. Wenn das Flag für mehrere Zeilen (multiline flag) auf true gesetzt wurde, wird auch eine Übereinstimmung direkt hinter dem Zeichen für einen Zeilenumbruch (\n) gefunden.</p>
        <p>Der Ausdruck <code>/^A/</code> passt zwar auf das "A" in "Apfel", nicht&nbsp; jedoch auf das "A" in "Ein Apfel", weil das "A" bei letzterer Zeichenkette nicht am Anfang steht.</p>
        <p>Achtung: Wenn das Zeichen innerhalb von eckigen Klammern (einer Zeichenauswahl) steht, hat es eine andere Bedeutung (siehe <a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-negated-character-set" id="special-negated-character-set" name="special-negated-character-set"><code>[^xyz]</code></a> in dieser Tabelle).</p>
        <p>Zum Beispiel stimmt <code>/[^a-zA-Z\s]/</code> mit der "3" in "Ich habe 3 Schwestern" überein. Die eckigen Klammern kennzeichnen die Zeichenauswahl. Das Zirkumflex innerhalb dieser Klammern negiert die aufgezählten Zeichen: nicht a bis z, nicht A bis Z und keine Leerräume wie das Leerzeichen oder die Steuerzeichen; übrig bleibt allein die "3".</p>
      </td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-dollar" id="special-dollar" name="special-dollar"><code>$</code></a></td>
      <td>
        <p>Das Dollarzeichen steht für das Ende der Eingabe. Wenn das Flag für mehrere Zeilen (multiline flag) auf true gesetzt ist, wird auch eine Übereinstimmung direkt hinter dem Zeichen für einen Zeilenumbruch (\n) gefunden.</p>
        <p>Zum Beispiel wird mit <code>/t$/</code> bei "Butter" keine Übereinstimmung gefunden, jedoch bei "Brot", weil das "t" am Ende steht.</p>
      </td>
    </tr>
    <tr>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-asterisk" id="special-asterisk" name="special-asterisk"><code>*</code></a></td>
      <td>
        <p>Das Sternchen steht für eine beliebige Anzahl des vorangestellten Zeichens, also 0-mal oder öfter. Das Zeichen muss also nicht unbedingt vorkommen, sondern darf auch einfach nicht vorhanden sein. Das Sternchen wird gerne in Kombination mit dem . (Punkt) als Platzhalter für "ein beliebiges Zeichen beliebig oft" verwendet.</p>
        <p>Der Ausdruck <code>/bu*/</code> passt auf "buuuuu" in "Ein Geist buuuuuht" als auch auf "b"&nbsp; in "Ein Blauwal blubbert", jedoch nicht auf "Eine Katze kratzt".</p>
      </td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-plus" id="special-plus" name="special-plus"><code>+</code></a></td>
      <td>
        <p>Steht für das vorangestellte Zeichen einmal oder öfter und ist equivalent zu {1,}. Das Zeichen muss für einen Treffer also mindestens einmal vorkommen.</p>
        <p>Zum Beispiel passt <code>/a+/</code> auf "a" in "Schokolade" und alle a's in "Schokolaaaade".</p>
      </td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-questionmark" id="special-questionmark" name="special-questionmark"><code>?</code></a></td>
      <td>
        <p>Steht für das vorangestellte Zeichen 0 oder einmal und ist equivalent zu {0,1}.</p>
        <p>Zum Beispiewird passt <code>/e?le?/</code> sowohl auf "el" in "Engel", als auch auf "le" in "Kapelle" und auch "l" in "Oslo".</p>
        <p>Wenn es sofort hinter einen der Quantoren <code>*</code>, <code>+</code>, <code>?</code>, oder <code>{}</code> gestellt wird, deaktiviert es die standardmäßige&nbsp; "Gierigkeit" (eine möglichst hohe Anzahl von passende Zeichen einschließend) dieser Quantoren und macht sie "genügsam" (eine möglichst geringe Anzahl von passende Zeichen einschließend).</p>
        <p>Zum Beispiel passt der Ausdruck /\d+/ nicht-global auf die Zeichenkette "123abc" angewendet auf "123", weil der Quantor + (Pluszeichen) "gierig" ist. Der Ausdruck /\d+?/ steht hingegen nur für "1", weil der Quantor + (Pluszeichen) aufgrund der Beeinflussung durch das hintangestellte ? (Fragezeichen) "genügsam" ist.</p>
        <p>Das Fragezeichen wird auch bei sogenannten <em>lookahead assertions</em> (vorausschauenden Annahmen/Behauptungen) eingesetzt, die in dieser Tabelle unter <a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-lookahead" id="special-lookahead" name="special-lookahead"><code>x(?=y)</code></a> und <a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-negated-look-ahead" id="special-negated-look-ahead" name="special-negated-look-ahead"><code>x(?!y)</code></a> beschrieben sind.</p>
      </td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-dot" id="special-dot" name="special-dot"><code>.</code></a></td>
      <td>
        <p>Der Punkt steht für ein einzelnes Zeichen mit Ausnahme des Zeichens für den Zeilenumbruch.</p>
        <p>Zum Beispiel passt <code>/.n/</code> auf "in" und "än" in der Zeichenkette "nur ein Apfel hängt am Baum", jedoch nicht auf das "n" ganz am Anfang.</p>
      </td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-capturing-parentheses" id="special-capturing-parentheses" name="special-capturing-parentheses"><code>(x)</code></a></td>
      <td>
        <p>Steht für "x", also die eingeklammerten Zeichen. Die passenden Zeichen des Musters innerhalb der Klammern werden gespeichert, damit sie an anderer Stelle wieder eingesetzt werden können. Die Klammern werden auch "capturing parentheses" (aufnehmende Klammern) genannt.</p>
        <p>Zum Beispiel steht <code>/(foo)/</code> für "foo" in "foobar" und gleichzeitig wird "foo" gespeichert. Die passenden Zeichen können durch Array-Elemente wieder eingesetzt werden. Dabei steht <code>[1]</code> für die Zeichen des ersten Klammerpaars, <code>[2]</code> für die Zeichen des zweiten Paars usw.</p>
      </td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-non-capturing-parentheses" id="special-non-capturing-parentheses" name="special-non-capturing-parentheses"><code>(?:x)</code></a></td>
      <td>Steht für&nbsp; "x", aber die Übereinstimmung wird nicht gespeichert. Diese Klammern werden auch als "non-capturing parentheses" bezeichnet. Die übereinstimmenden Zeichen können nicht wieder eingesetzt werden und die Array-Elemente <code>[1]</code>, ..., <code>[n]</code> finden keine Anwendung.</td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-lookahead" id="special-lookahead" name="special-lookahead"><code>x(?=y)</code></a></td>
      <td>
        <p>Steht für "x", jedoch nur wenn "x" vor "y" steht. Dies wird als<em> lookahead</em> (Vorausschauen) bezeichnet.</p>
        <p>Zum Beispiel passt <code>/Jack(?=Sprat)/</code> auf "Jack" nur dann, wenn "Sprat" dahinter steht. Der Ausdruck <code>/Jack(?=Sprat|Frost)/</code> passt auf "Jack" nur dann, wenn dahinter "Sprat" oder "Frost" steht. Doch weder "Sprat" noch "Frost" ist Teil des übereinstimmenden Ergenisses.</p>
      </td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-negated-look-ahead" id="special-negated-look-ahead" name="special-negated-look-ahead"><code>x(?!y)</code></a></td>
      <td>
        <p>Passt nur dann auf "x", wenn "x" nicht vor "y" steht. Dies wird auch als <em>negated lookahead</em> (negierte vorausschauende Annahmen) bezeichnet.</p>
        <p>Zum Beispiel passt <code>/\d+(?!\.)/</code> nur dann auf eine Nummer, wenn diese nicht vor einem Dezimalpunkt steht. Der reguläre Ausdruck <code>/\d+(?!\.)/.exec("3.141")</code>&nbsp; passt auf "141", jedoch nicht auf "3.141".</p>
      </td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-or" id="special-or" name="special-or"><code>x|y</code></a></td>
      <td>
        <p>Passt auf entweder "x" oder "y".</p>
        <p>Zum Beispiel passt der Ausdruck <code>/grüner|roter/</code>&nbsp; auf "grüner" in "grüner Apfel" und "roter" in "roter Apfel".</p>
      </td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-quantifier" id="special-quantifier" name="special-quantifier"><code>{n}</code></a></td>
      <td>
        <p>Das <code>n</code> steht für eine postive ganze Zahl. Das Muster passt exakt auf die Anzahl <code>n</code> des vorangestellten Zeichens.</p>
        <p>Zum Beispiel passt <code>/a{2}/</code> nicht auf das "a" in "Schokolade",&nbsp; jedoch auf alle a's in "Schokolaade" und die ersten beiden a's in "Schokolaaade".</p>
      </td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-quantifier-range" id="special-quantifier-range" name="special-quantifier-range"><code>{n,m}</code></a></td>
      <td>
        <p>Wobei <code>n</code> und <code>m</code> positive ganze Zahlen sind. Passt auf mindests <code>n</code> und höchstens <code>m</code> Vorkommen des vorangestellten Zeichens. Wenn für <code>n</code> oder <code>m</code> eine 0 stehen soll, kann sie auch weggelassen werden.</p>
        <p>Zum Beispiel passt <code>/a{1,3}/</code> auf nichts in "cndy", jedoch auf das "a" in "candy", die beiden a's in "caandy," und die ersten drei a's in "caaaaaaandy".&nbsp; Merke: Wenn der Ausdruck auf "caaaaaaandy" angewendet wird, ist die Übereinstimmung "aaa", auch wenn in der Zeichenkette mehr a's enthalten sind.</p>
      </td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-character-set" id="special-character-set" name="special-character-set"><code>[xyz]</code></a></td>
      <td>
        <p>Die eckigen Klammern kennzeichnen eine Zeichenauswahl. Der Ausdruck stimmt mit allen in den Klammern stehenden Zeichen überein. Mit Hilfe eines Bidestrichs kann ein Bereich (von a bis z) festgelegt werden. Spezielle Zeichen (wie der Punkt (.) oder das Sternchen (*)) haben keine spezielle Bedeutung innerhalb der eckigen Klammern. Sie müssen nicht "escaped" werden. Escape-Sequenzen funktionieren also auch.</p>
        <p>Zum Beispiel ist <code>[abcd]</code> dasselbe wie <span style="font-family: monospace;">[</span><code>a-d]</code>. Beides passt auf das "b" in "biegen" und das "d" in "denken". Die Ausdrücke<code> /[a-z.]+/</code> und <code>/[\w.]+/</code> passen beide auf "test.i.ng".</p>
      </td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-negated-character-set" id="special-negated-character-set" name="special-negated-character-set"><code>[^xyz]</code></a></td>
      <td>
        <p>Eine negierte oder komplementäre Zeichenauswahl. Das Zirkumflex-Zeichen an erster Stelle in den Klammern negiert die Zeichenauswahl. Der Ausdruck passt also auf alle Zeichen, die nicht in den Klammern stehen. Es kann mit Hilfe eines Bindestrichs auch ein Bereich von Zeichen spezifiziert werden. Alle Zeichen, die bei einer normalen Zeichenauswahl funktionieren, funktionieren hier ebenso.</p>
        <p>Zum Beispiel ist <code>[^abc]</code> dasselbe wie <code>[^a-c]</code>. Beide Ausdrücke passen auf das "r" in "brechen" und das "m" in "campen".</p>
      </td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-backspace" id="special-backspace" name="special-backspace"><code>[\b]</code></a></td>
      <td>Passt auf das Steuerzeichen für die Backspace-Taste (U+0008). (Sollte nicht mit <code>\ b</code> verwechselt werden.)</td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-word-boundary" id="special-word-boundary" name="special-word-boundary"><code>\b</code></a></td>
      <td>
        <p>Steht für eine Wortgrenze. Wortgrenzen sind an den Stellen, wo kein anderes Wortzeichen vor oder hinter einem Wortzeichen steht. Eine Wortgrenze wird nicht in die Übereinstimmung aufgenommen. Mit anderen Worten ist die Länge einer Wortgrenze gleich 0 - die Wortgrenze ist der Zwischenraum zwischen einem Wortzeichen und einem Zeichen, das kein Wortzeichen ist oder zwischen einem Wortzeichen und dem Anfang oder Ende der Eingabe. (Sollte nicht mit <code>[\b]</code> verwechselt werden.)</p>
        <p>Beispiele:<br />
          <code>/\bMon/</code> passt auf das "Mon" in "Mond" ;<br />
          <code>/ll\b/</code> passt nicht auf "ll" in "Falle", weil "ll" nicht vor einer Wortgrenze steht, sondern vor dem Zeichen "e", wobei es sich um ein Wortzeichen handelt.<br />
          <code>/ond\b/</code> passt auf das "ond" in "Mond", weil "ond"&nbsp; das Ende der Zeichenkette ist, also nicht vor einem Wortzeichen steht.<br />
          <code>Bei /\w\b\w/</code> wird niemals eine Übereinstimmung gefunden, weil eine Wortgrenze niemals gleichzeitig vor einem Wortzeichen und keinem Wortzeichen stehen kann.</p>
      </td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-non-word-boundary" id="special-non-word-boundary" name="special-non-word-boundary"><code>\B</code></a></td>
      <td>
        <p>Steht für alle Zeichen, die keine Wortgrenze sind. Dies trifft auf Positionen zu, wo zwei nebeneinanderstehende Zeichen vom selben Typ sind: Entweder sind beide Wortzeichen oder keine Wortzeichen. Der Anfang und das Ende einer Zeichenkette werden nicht als Wortzeichen angesehen, gelten also als Wortgrenzen.</p>
        <p>Zum Beispiel passt <code>/\B../</code> <span style="color:#a52a2a;">auf "oo" in "noonday" und <code>/y\B./</code> auf "ye" in "possibly yesterday."</span></p>
      </td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-control" id="special-control" name="special-control"><code>\c<em>X</em></code></a></td>
      <td>
        <p><em>X</em> ist ein Zeichenbereich von A bis Z. Passt auf ein Steuerzeichen in einer Zeichkette.</p>
        <p>Zum Beispiel steht <code>/\cM/</code> für das Steuerzeichen control-M (U+000D) in einer Zeichenkette.</p>
      </td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-digit" id="special-digit" name="special-digit"><code>\d</code></a></td>
      <td>
        <p>Steht für Ziffern und ist equivalent zu <code>[0-9]</code>.</p>
        <p>Zum Beispiel passt <code>/\d/</code> oder <code>/[0-9]/</code> auf "2" in "B2 ist die Zimmernummer."</p>
      </td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-non-digit" id="special-non-digit" name="special-non-digit"><code>\D</code></a></td>
      <td>
        <p>Steht für alle nicht-Ziffern und ist equivalent zu <code>[^0-9]</code>.</p>
        <p>Zum Beispiel passt <code>/\D/</code> oder <code>/[^0-9]/</code> auf "B" in "B2 ist die Zimmernummer."</p>
      </td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-form-feed" id="special-form-feed" name="special-form-feed"><code>\f</code></a></td>
      <td>Steht für einen Seitenvorschub (<strong>engl. <em>f</em></strong><em>orm feed</em> (U+000C)).</td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-line-feed" id="special-line-feed" name="special-line-feed"><code>\n</code></a></td>
      <td>Steht für einen Zeilenbruch (engl. <em>line feed</em> bzw. <em><strong>n</strong>ew line</em> U+000A).</td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-carriage-return" id="special-carriage-return" name="special-carriage-return"><code>\r</code></a></td>
      <td>Steht für einen Waagenrücklauf (engl. <em>carriage <strong>r</strong>eturn</em> (U+000D).</td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-white-space" id="special-white-space" name="special-white-space"><code>\s</code></a></td>
      <td>
        <p>Steht für ein einzelnes Leerraum-Zeichen, einschließlich Leertaste, Tabulator, Seitenvorschub und Zeilenumbruch und ist equivalent zu <code>[ \f\n\r\t\v​\u00A0\u1680​\u180e\u2000​\u2001\u2002​\u2003\u2004​ \u2005\u2006​\u2007\u2008​\u2009\u200a​\u2028\u2029​\u2028\u2029​ \u202f\u205f​\u3000]</code>.</p>
        <p>Zum Beispiel passt <code>/\s\w*/</code> auf "bar" in "foo bar".</p>
      </td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-non-white-space" id="special-non-white-space" name="special-non-white-space"><code>\S</code></a></td>
      <td>
        <p>Steht für ein einzelnes Zeichen, das kein Leerraum-Zeichen ist. Equivalent zu <code>[^ \f\n\r\t\v​\u00A0\u1680​\u180e\u2000​\u2001\u2002​\u2003\u2004​ \u2005\u2006​\u2007\u2008​\u2009\u200a​\u2028\u2029​\u2028\u2029​ \u202f\u205f​\u3000]</code>.</p>
        <p>Zum Beispiel passt <code>/\S\w*/</code> auf "foo" in "foo bar".</p>
      </td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-tab" id="special-tab" name="special-tab"><code>\t</code></a></td>
      <td>Steht für einen Tabulator (engl. <em>horizontal <strong>t</strong>ab</em> U+0009).</td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-vertical-tab" id="special-vertical-tab" name="special-vertical-tab"><code>\v</code></a></td>
      <td>Steht für einen vertikalen Tabulator (engl. <em><strong>v</strong>ertical tabulator</em> (U+000B).</td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-word" id="special-word" name="special-word"><code>\w</code></a></td>
      <td>
        <p>Steht für ein alphanumerisches Zeichen (Wortzeichen), einschließlich Unterstrich. Equivalent zu <code>[A-Za-z0-9_]</code>.</p>
        <p>Zum Biespiel passt <code>/\w/</code> auf "a" in "apple" als auch auf "5" in "$5.28" und "3" in "3D".</p>
      </td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-non-word" id="special-non-word" name="special-non-word"><code>\W</code></a></td>
      <td>
        <p>Steht für ein nicht-alphanumerisches Zeichen (nicht-Wortzeichen). Equivalent zu <code>[^A-Za-z0-9_]</code>.</p>
        <p>Zum Beispiel passt <code>/\W/</code> oder <code>/[^A-Za-z0-9_]/</code> auf "%" in "50%".</p>
      </td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-backreference" id="special-backreference" name="special-backreference"><code>\<em>n</em></code></a></td>
      <td>
        <p>Stellt einen Rückgriff auf die passenden Zeichen eines eingeklammerten Teilausdrucks dar, wobei <em>n</em> eine positive ganze Zahl ist. Die Zahl steht hierbei für das jeweilge Teilmuster innerhalb eines Klammerpaars an entsprechender Stelle (öffnende Klammern werden gezählt).</p>
        <p>Zum Beispiel passt <code>/Apfel(,)\sOrange\1/</code> auf "Apfel, Orange," in "Apfel, Orange, Kirsche, Pfirsich".</p>
      </td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-null" id="special-null" name="special-null"><code>\0</code></a></td>
      <td>Steht für ein NULL-Zeichen (U+0000). Es sollte kein Ziffer dahinter stehen, weil <code>\0&lt;Ziffer&gt;</code> eine Escape-Sequenz für oktale Zahlen ist.</td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-hex-escape" id="special-hex-escape" name="special-hex-escape"><code>\x<em>hh</em></code></a></td>
      <td>Steht für das Zeichen mit dem Code <em>hh</em> (zweistellige hexadezimale Zahl).</td>
    </tr>
    <tr>
      <td><a href="https://developer.mozilla.org/de/docs/JavaScript/Guide/Regular_Expressions$edit#special-unicode-escape" id="special-unicode-escape" name="special-unicode-escape"><code>\u<em>hhhh</em></code></a></td>
      <td>Steht für das Zeichen mit dem Code <em>hhhh</em> (vierstellige hexadezimale Zahl).</td>
    </tr>
  </tbody>
</table>
<h3>Benutzung von Klammern</h3>
<p>Klammern werden verwendet, um den eingeklammerten Teil des regulären Ausdrucks zu speichern. Einmal gespeichert kann dieser Teil an anderer Stelle wieder eingesetzt werden, wie unter <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Guide/Regular_Expressions#Using_Parenthesized_Substring_Matches">Benutzung von geklammerten Mustern</a> beschrieben.</p>
<p>Zum Beispiel beinhaltet der Ausdruck <code>/Kapitel (\d+)\.\d*/</code> einige maskierte und spezielle Zeichen. Mit den Klammern wird bewirkt, dass die Zeichen, welche mit dem eingeklammerten Muster übereinstimmen, gespeicert werden. Der Ausdruck stimmt genau mit der Zeichenkette "Kapitel " gefolgt von einer oder mehreren Ziffern (<code>\d</code> steht für eine Ziffer und das <code>+</code> (Pluszeichen) bedeutet 1 oder mehr Vorkommen), einem Punkt (der Punkt selbst ist standardmäßig ein spezielles Zeichen, weshalb er maskiert werden muss) und nochmal beliebig vielen Ziffern (\d steht für eine Ziffer und der Stern bedeutet 0 oder mehr Vorkommen) überein. Zusätzlich werden die Klammern eingesetzt, um die erste Ziffer zu speichern.</p>
<p>Eine Übereinstimmung wird z.B. in "Offenes Kapitel 4.3, Absatz 6" gefunden und dabei wird "4" gespeichert. Auf die Zeichenkette "Kapitel 3 und 4" passt der Ausdruck nicht, weil hinter der ersten Ziffer "3" kein Punkt steht.</p>
<p>Möchte man einen zusammenhängenden Teil einer Zeichenkette suchen, jedoch nicht speichern, setzt man <code>?:</code> an den Anfang innerhalb der Klammern. Zum Beispiel stimmt <code>(?:\d+)</code> mit einer oder mehr Ziffern überein, aber diese Ziffern werden nicht gespeichert.</p>
<h3>Arbeiten mit regulären Ausdrücken</h3>
<p>Reguläre Ausdrücke werden mit den Methoden <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/RegExp/exec" title="exec"><code>exec</code></a> und <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/RegExp/test" title="test"><code>test</code></a> von <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/RegExp" title="RegExp"><code>RegExp</code></a> und den Methoden <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/match" title="match"><code>match</code></a>, <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/replace" title="en-US/docs/JavaScript/Reference/Global_Objects/String/replace"><code>replace</code></a>,<a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/search" title="search"> <code>search</code></a> und <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/split" title="split"><code>split</code></a> von <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String" title="String"><code>String</code></a> verwendet. Diese Methoden sind in der <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference" title="en-US/docs/JavaScript/Reference">JavaScript Referenz</a> beschrieben.</p>
<table class="standard-table">
  <caption style="text-align: left">
    Table 4.2 Methoden die reguläre Ausdrücke verwenden</caption>
  <thead>
    <tr>
      <th scope="col">Method</th>
      <th scope="col">Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><code><a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/RegExp/exec" title="en-US/docs/JavaScript/Reference/Global_Objects/RegExp/exec">exec</a></code></td>
      <td>Eine Methode von <code>RegExp,</code> die eine Suche nach einer Übereinstimmung in einer Zeichenkette durchführt. Sie gibt ein Array mit den Übereinstimmungen zurück.</td>
    </tr>
    <tr>
      <td><code><a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/RegExp/test" title="en-US/docs/JavaScript/Reference/Global_Objects/RegExp/test">test</a></code></td>
      <td>Eine Methode von <code>RegExp</code>, die eine Zeichenkette auf eine Übereinstimmung überprüft. Sie gibt <code>true</code> oder <code>false</code> zurück.</td>
    </tr>
    <tr>
      <td><code><a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/match" title="en-US/docs/JavaScript/Reference/Global_Objects/String/match">match</a></code></td>
      <td>Eine Methode von <code>String</code>, die eine Suche nach einer Übereinstimmung in einer Zeichenkette durchführt. Sie gibt ein Array zurück oder <code>null</code> bei keinem Treffer.</td>
    </tr>
    <tr>
      <td><code><a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/search" title="en-US/docs/JavaScript/Reference/Global_Objects/String/search">search</a></code></td>
      <td>Eine Methode von <code>String</code>, die eine Zeichenkette auf eine Übereinstimmung überprüft. Sie gibt den Index der Übereinstimmung zurück oder -1 bei keinem Treffer.</td>
    </tr>
    <tr>
      <td><code><a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/replace" title="en-US/docs/JavaScript/Reference/Global_Objects/String/replace">replace</a></code></td>
      <td>Eine Methode von <code>String</code>, die eine Suche nach einer Übereinstimmung in einer Zeichenkette durchführt und die Übereinstimmungen durch eine andere Zeichenkette ersetzt.</td>
    </tr>
    <tr>
      <td><code><a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/split" title="en-US/docs/JavaScript/Reference/Global_Objects/String/split">split</a></code></td>
      <td>Eine Methode von <code>String</code>, die anhand eines regulären Ausdrucks oder einer festen Zeichkette eine Zeichenkette trennt und die Teile als Array zurückgibt.</td>
    </tr>
  </tbody>
</table>
<p>Wenn man nur wissen möchte, ob ein regulärer Ausdruck auf eine Zeichenkette passt, sollten die Methoden <code>test</code> oder <code>search</code> zum Einsatz kommen. Möchte man mehr erfahren, sollte man auf die Methoden <code>exec</code> oder <code>match</code> zurückgreifen (langsamere Ausführsgeschwindigkeit). Die Methoden <code>exec</code> und <code>match</code> geben ein Array zurück falls Übereinstimmungen gefunden werden und updaten die Eigenschaften des zugehörigen <code>RegExp</code>-Objekts und des vordefinierten <code>RegExp</code>-Objekts. Wenn keine Übereinstimmungen gefunden werden, geben die Methoden <code>null</code> (konvertiert: <code>false</code>) zurück.</p>
<p>Bei fogendem Beispiel kommt die Methode exec zum Einsatz, um eine Übereinstimmung in einer Zeichnkette zu finden.&nbsp;&nbsp;</p>
<pre class="brush: js">
var myRe = /d(b+)d/g;
var myArray = myRe.exec("cdbbdbsbz");
</pre>
<p>Wenn man auf die Eingenschaften des Objekts für den regulären Ausdruck nicht zugreifen möchte, kann man <code>myArray</code> auch direkt wie folgt erzeugen:</p>
<pre class="brush: js">
var myArray = /d(b+)d/g.exec("cdbbdbsbz");
</pre>
<p>Möchte man den regulären Ausdruck aus einem String erzeugen, besteht folgende Möglichkeit:</p>
<pre class="brush: js">
var myRe = new RegExp("d(b+)d", "g");
var myArray = myRe.exec("cdbbdbsbz");
</pre>
<p>Bei diesen Skripten werden Übereinstimmungen gefunden. Es wird ein Array zurückgegeben und die Eigenschaften geupdatet, welche in der nachstehenden Tabelle aufgelistet sind.</p>
<table class="fullwidth-table">
  <caption style="text-align: left">
    Tabelle 4.3 Ergebnisse von regulären Ausdrücken</caption>
  <thead>
    <tr>
      <th scope="col">Objekt</th>
      <th scope="col">Eigenschaft oder Index</th>
      <th scope="col">Beschreibung</th>
      <th scope="col">Bei diesem Beispiel</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td rowspan="4"><code>myArray</code></td>
      <td>&nbsp;</td>
      <td>Die übereinstimmende Zeichenfolge und alle gespeicherten Teile.</td>
      <td><code>["dbbd", "bb"]</code></td>
    </tr>
    <tr>
      <td><code>index</code></td>
      <td>Der mit 0 beginnende Index der Übereinstimmung in der Eingabe-Zeichenkette.</td>
      <td><code>1</code></td>
    </tr>
    <tr>
      <td><code>input</code></td>
      <td>Die ursprüngliche Eingabe-Zeichenkette.</td>
      <td><code>"cdbbdbsbz"</code></td>
    </tr>
    <tr>
      <td><code>[0]</code></td>
      <td>Die zuletzt übereinstimmenden Zeichen.</td>
      <td><code>"dbbd"</code></td>
    </tr>
    <tr>
      <td rowspan="2"><code>myRe</code></td>
      <td><code>lastIndex</code></td>
      <td>Der Index bei dem die nächste Suche nach einer Übereinstimmung gestartet wird.&nbsp; (Diese Eigenschaft wird nur gesetzt, wenn im regulären Ausdruck die Option "g" verwendet wird, wie unter {{ web.link("#Advanced_Searching_With_Flags", "Advanced Searching With Flags") }} beschrieben).</td>
      <td><code>5</code></td>
    </tr>
    <tr>
      <td><code>source</code></td>
      <td>Der Text des Musters - wird geupdatet wenn der reguläre Ausdruck erstellt wird, nicht bei der Ausführung.</td>
      <td><code>"d(b+)d"</code></td>
    </tr>
  </tbody>
</table>
<p>Wie das zweite Beispiel zeigt, kann man einen regulären Ausdruck einsetzen, der über einen Objekt-intializer erstellt wurde, ohne die Zuweisung einer Variablen. Bei dieser Vorgehensweise ist jede Übereinstimmung ein neuer Ausdruck. Aus diesem Grund kann nicht auf die Eigenschaften dieses regulären Ausdrucks zugegriffen werden. Angenommen man hat z.B. dieses Skript:</p>
<pre class="brush: js">
var myRe = /d(b+)d/g;
var myArray = myRe.exec("cdbbdbsbz");
console.log("Der Wert von lastIndex ist " + myRe.lastIndex);
</pre>
<p>Dann ist die Ausgabe:</p>
<pre>
Der Wert von lastIndex ist 5
</pre>
<p>Hat man nun aber dieses Skript:</p>
<pre class="brush: js">
var myArray = /d(b+)d/g.exec("cdbbdbsbz");
console.log("Der Wert von lastIndex ist " + /d(b+)d/g.lastIndex);
</pre>
<p>Dann ist die Ausgabe:</p>
<pre>
Der Wert von lastIndex ist 0
</pre>
<p>Die einzelnen Vorkommen der Zeichenfolgen, die mit <code>/d(b+)d/g</code> übereinstimmen sind bei den beiden Anweisungen verschiedene Objekte und haben dementstrechend auch verschiedene Werte bei der jeweiligen Eigenschaft <code>lastIndex</code>. Falls man auf die Eigenschaften eines Objekts eines regulärenAusdrucks zugreifen möchte, sollte man diesen vorher einer Variablen zuweisen.</p>
<h3 id="Using_Parenthesized_Substring_Matches">Benutzung von geklammerten Mustern</h3>
<p>Klammern werden verwendet, um einen Teil der Zeichen, die mit dem regulären Ausdruck übereinstimmen, zu speichern. Zum Beispiel stimmt&nbsp;<code>/a(b)c/</code> mit der Zeichenfolge "abc" überein und "b" wird gespeichert. Um die gespiecherten Zeichen wieder abzurufen, verwendet man die <code>Array</code>-Elemente <code>[1]</code>, ..., <code>[n]</code>.</p>
<p>Die Anzahl der möglichen speicherbaren Teile ist nicht limitiert. Das Array, welches zurückgegeben wird, enthält alle gespeicherten Übereinstimmungen. Die folgenden Beispiele zeigen auf, wie man geklammerte Muster einsetzt.</p>
<h4 id="Example_1">Beispiel 1</h4>
<p>Das folgende Skript benutzt die Methode <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/replace" title="en-US/docs/JavaScript/Reference/Global Objects/String/replace"><code>replace()</code></a>, um Wörter in einer Zeichenkette auszutauschen. Die beiden Muster für die Wörter (<code>\w+</code>) wurden geklammert, damit die Wörter gespeichert werden. Anschließend werden im Ersetzungstext diese gespeicherten Wörter mit <code>$1</code> und <code>$2</code> wieder eingesetzt.</p>
<pre class="brush: js">
var re = /(\w+)\s(\w+)/;
var str = "Jonas Schmidt";
var newstr = str.replace(re, "$2, $1");
console.log(newstr);
</pre>
<p>Die Ausgabe ist "Schmidt, Jonas".</p>
<h3 id="Advanced_Searching_With_Flags">Erweiterte Suche mit Optionen (Flags)</h3>
<p>Reguläre Ausdrücke kennen vier verschiedene Optionen (Flags), die es z. B. erlauben global nach Übereinstimmungen zu suchen oder die Berücksichtigung der Groß- und Kleinschreibweise zu deaktivieren. Zur Aktivierung der <strong>g</strong>lobalen Suche wird das Flag <code>g</code> eingesetzt. Die Berücksichtigung der Groß- und Kleinschreibweise (<i>engl. case-<strong>i</strong>nsensitive</i>) wird mit dem Flag <code>i</code> abgeschaltet. Die mehrzeilige Suche (engl. <strong>m</strong>ultiline) wird mit dem Flag <code>m</code> aktiviert und eine "sticky" Suche, wobei die Übereinstimmung an der aktuellen Postion im Eingabe-Zeichenkette zutreffen muss, wird mit dem Flag <code>y</code> aktiviert. Diese Optionen können getrennt oder gemeinsam verwendet und in beliebiger Reihenfolge angegeben werden. Die Buchsaben werden durch <code>/</code> getrennt an den regulären Ausdruck angehängt.</p>
<p>{{ Fx_minversion_note(3, "Die Unterstützung für das Flag <code>y</code> wurde bei Firefox 3 hinzugefügt. Wenn <code>y</code> aktiviert ist, schlägt die Suche fehl, wenn es keine Übereinstimmung an der aktuellen Position innerhalb der Eingabe-Zeichenkette gibt.") }}</p>
<p>Syntax für die Verwendung von Optionen:</p>
<pre class="brush: js">
var re = /Muster/Optionen;
</pre>
<p>oder</p>
<pre class="brush: js">
var re = new RegExp("Muster", "Optionen");
</pre>
<p>Die Optionen sind ein integraler Bestandteil des regulären Ausdrucks. Sie können nicht im Nachhinein entfernt oder hinzugefügt werden.</p>
<p>For example, <code>re = /\w+\s/g</code> creates a regular expression that looks for one or more characters followed by a space, and it looks for this combination throughout the string.</p>
<pre class="brush: js">
var re = /\w+\s/g;
var str = "fee fi fo fum";
var myArray = str.match(re);
console.log(myArray);
</pre>
<p>This displays ["fee ", "fi ", "fo "]. In this example, you could replace the line:</p>
<pre class="brush: js">
var re = /\w+\s/g;
</pre>
<p>with:</p>
<pre class="brush: js">
var re = new RegExp("\\w+\\s", "g");
</pre>
<p>and get the same result.</p>
<p>The <code>m</code> flag is used to specify that a multiline input string should be treated as multiple lines. If the <code>m</code> flag is used, <code>^</code> and <code>$</code> match at the start or end of any line within the input string instead of the start or end of the entire string.</p>
<h2 id="Examples">Examples</h2>
<p>The following examples show some uses of regular expressions.</p>
<h3 id="Changing_the_Order_in_an_Input_String">Changing the Order in an Input String</h3>
<p>The following example illustrates the formation of regular expressions and the use of <code>string.split()</code> and <code>string.replace()</code>. It cleans a roughly formatted input string containing names (first name first) separated by blanks, tabs and exactly one semicolon. Finally, it reverses the name order (last name first) and sorts the list.</p>
<pre class="brush: js">
// The name string contains multiple spaces and tabs,
// and may have multiple spaces between first and last names.
var names = "Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ; Chris Hand ";

var output = ["---------- Original String\n", names + "\n"];

// Prepare two regular expression patterns and array storage.
// Split the string into array elements.

// pattern: possible white space then semicolon then possible white space
var pattern = /\s*;\s*/;

// Break the string into pieces separated by the pattern above and
// store the pieces in an array called nameList
var nameList = names.split(pattern);

// new pattern: one or more characters then spaces then characters.
// Use parentheses to "memorize" portions of the pattern.
// The memorized portions are referred to later.
pattern = /(\w+)\s+(\w+)/;

// New array for holding names being processed.
var bySurnameList = [];

// Display the name array and populate the new array
// with comma-separated names, last first.
//
// The replace method removes anything matching the pattern
// and replaces it with the memorized string—second memorized portion
// followed by comma space followed by first memorized portion.
//
// The variables $1 and $2 refer to the portions
// memorized while matching the pattern.

output.push("---------- After Split by Regular Expression");

var i, len;
for (i = 0, len = nameList.length; i &lt; len; i++){
  output.push(nameList[i]);
  bySurnameList[i] = nameList[i].replace(pattern, "$2, $1");
}

// Display the new array.
output.push("---------- Names Reversed");
for (i = 0, len = bySurnameList.length; i &lt; len; i++){
  output.push(bySurnameList[i]);
}

// Sort by last name, then display the sorted array.
bySurnameList.sort();
output.push("---------- Sorted");
for (i = 0, len = bySurnameList.length; i &lt; len; i++){
  output.push(bySurnameList[i]);
}

output.push("---------- End");

console.log(output.join("\n"));
</pre>
<h3 id="Using_Special_Characters_to_Verify_Input">Using Special Characters to Verify Input</h3>
<p>In the following example, the user is expected to enter a phone number. When the user presses the "Check" button, the script checks the validity of the number. If the number is valid (matches the character sequence specified by the regular expression), the script shows a message thanking the user and confirming the number. If the number is invalid, the script informs the user that the phone number is not valid at all.</p>
<p>The regular expression looks for zero or one open parenthesis <code>\(?</code>, followed by three digits<code> \d{3}</code>, followed by zero or one close parenthesis <code>\)?</code>, followed by one dash, forward slash, or decimal point and when found, remember the character <code>([-\/\.])</code>, followed by three digits <code>\d{3}</code>, followed by the remembered match of a dash, forward slash, or decimal point <code>\1</code>, followed by four digits <code>\d{4}</code>.</p>
<p>The <code>Change</code> event activated when the user presses Enter sets the value of <code>RegExp.input</code>.</p>
<pre class="brush: html">
&lt;!DOCTYPE html&gt;
&lt;html&gt;  
  &lt;head&gt;  
    &lt;meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"&gt;  
    &lt;meta http-equiv="Content-Script-Type" content="text/javascript"&gt;  
    &lt;script type="text/javascript"&gt;  
      var re = /\(?\d{3}\)?([-\/\.])\d{3}\1\d{4}/;  
      function testInfo(phoneInput){  
        var OK = re.exec(phoneInput.value);  
        if (!OK)  
          window.alert(RegExp.input + " isn't a phone number with area code!");  
        else
          window.alert("Thanks, your phone number is " + OK[0]);  
      }  
    &lt;/script&gt;  
  &lt;/head&gt;  
  &lt;body&gt;  
    &lt;p&gt;Enter your phone number (with area code) and then click "Check".
        &lt;br&gt;The expected format is like ###-###-####.&lt;/p&gt;
    &lt;form action="#"&gt;  
      &lt;input id="phone"&gt;&lt;button onclick="testInfo(document.getElementById('phone'));"&gt;Check&lt;/button&gt;
    &lt;/form&gt;  
  &lt;/body&gt;  
&lt;/html&gt;
</pre>
<p>&nbsp;</p>
Zu dieser Version zurücksetzen