Reguläre Ausdrücke

Beschreibung

Reguläre Ausdrücke sind ein wichtiges Konzept der Theorie formaler Sprachen. Mit ihnen lässt sich eine möglicherweise unendliche Menge von Zeichenfolgen beschreiben (eine sogenannte Sprache). Im Kern benötigt ein regulärer Ausdruck die folgenden Bestandteile:

• Eine Menge von Zeichen, die in der Sprache verwendet werden können, das sogenannte Alphabet.
• Verkettung: ab bedeutet „das Zeichen a, gefolgt vom Zeichen b“.
• Vereinigung: a|b bedeutet „entweder a oder b“.
• Kleene-Stern: a* bedeutet „null oder mehr a-Zeichen“.

Unter der Annahme eines endlichen Alphabets (etwa der 26 Buchstaben des englischen Alphabets oder des gesamten Unicode-Zeichensatzes) lassen sich alle regulären Sprachen mit den oben genannten Bestandteilen erzeugen. Viele Muster wären auf diese Weise allerdings sehr umständlich auszudrücken (etwa „10 Ziffern“ oder „ein Zeichen, das kein Leerzeichen ist“). Deshalb bieten reguläre Ausdrücke in JavaScript zahlreiche Kurzschreibweisen, die im Folgenden vorgestellt werden.

Reguläre Ausdrücke erstellen

Ein regulärer Ausdruck wird normalerweise als Literal erstellt, indem ein Muster in Schrägstriche (/) eingeschlossen wird:

const regex1 = /ab+c/g;

Reguläre Ausdrücke können auch mit dem Konstruktor RegExp() erstellt werden:

const regex2 = new RegExp("ab+c", "g");

Zur Laufzeit unterscheiden sich die beiden Varianten nicht. Sie können sich jedoch auf die Leistung und die statische Analysierbarkeit auswirken sowie die Erstellung durch erforderliches Escaping von Zeichen unterschiedlich aufwendig machen. Weitere Informationen finden Sie in der Referenz zu RegExp.

Regex-Flags

Flags sind spezielle Parameter, die beeinflussen können, wie ein regulärer Ausdruck interpretiert wird oder wie er mit dem Eingabetext interagiert. Jedem Flag entspricht eine Zugriffseigenschaft des RegExp-Objekts.

Die Flags i, m und s können mithilfe der Modifier-Syntax für bestimmte Teile eines regulären Ausdrucks aktiviert oder deaktiviert werden.

Die folgenden Abschnitte führen alle verfügbaren Regex-Syntaxformen auf, gruppiert nach ihrer syntaktischen Funktion.

Assertions

Assertions sind Konstrukte, die prüfen, ob die Zeichenfolge an einer bestimmten Position eine Bedingung erfüllt, ohne Zeichen zu verbrauchen. Assertions können nicht quantifiziert werden.

Assertion für die Zeichenfolgengrenze: \A, \z, \Z

Prüft, ob die aktuelle Position genau am Anfang oder Ende der gesamten Zeichenfolge liegt (\Z lässt auch einen abschließenden Zeilenumbruch zu), unabhängig davon, ob das Flag m gesetzt ist.

Assertion für die Eingabegrenze: ^, $

Prüft, ob die aktuelle Position am Anfang oder Ende der Eingabe liegt oder, wenn das Flag m gesetzt ist, am Anfang oder Ende einer Zeile.

Lookahead-Assertion: (?=...), (?!...)

Prüft, ob auf die aktuelle Position ein bestimmtes Muster folgt oder nicht folgt.

Lookbehind-Assertion: (?<=...), (?<!...)

Prüft, ob der aktuellen Position ein bestimmtes Muster vorausgeht oder nicht vorausgeht.

Assertion für Wortgrenzen: \b, \B

Prüft, ob die aktuelle Position eine Wortgrenze ist.

Atome

Atome sind die grundlegenden Einheiten eines regulären Ausdrucks. Jedes Atom verbraucht null oder mehr Zeichen der Zeichenfolge und bewirkt entweder, dass der Abgleich fehlschlägt, oder ermöglicht die Fortsetzung des Abgleichs mit dem nächsten Atom.

Backreference: \1, \2

Stimmt mit einem zuvor abgeglichenen Teilmuster überein, das mit einer Capturing Group erfasst wurde.

Capturing Group: (...)

Stimmt mit einem Teilmuster überein und speichert Informationen über die Übereinstimmung.

Character Class: [...], [^...]

Stimmt mit einem beliebigen Zeichen aus einer Zeichenmenge beziehungsweise außerhalb dieser Menge überein. Wenn das Flag v aktiviert ist, können damit auch Zeichenfolgen endlicher Länge abgeglichen werden.

Character-Class-Escape: \d, \D, \w, \W, \s, \S

Stimmt mit einem beliebigen Zeichen aus einer vordefinierten Zeichenmenge beziehungsweise außerhalb dieser Menge überein.

Character Escape: \n, \u{...}

Stimmt mit einem Zeichen überein, das sich möglicherweise nicht gut in seiner literalen Form darstellen lässt.

Literales Zeichen: a, b

Stimmt mit einem bestimmten Zeichen überein.

Modifier: (?ims-ims:...)

Überschreibt Flag-Einstellungen in einem bestimmten Teil eines regulären Ausdrucks.

Benannte Backreference: \k<name>

Stimmt mit einem zuvor abgeglichenen Teilmuster überein, das mit einer benannten Capturing Group erfasst wurde.

Benannte Capturing Group: (?<name>...)

Stimmt mit einem Teilmuster überein und speichert Informationen über die Übereinstimmung. Die Gruppe kann später anhand eines selbst gewählten Namens statt anhand ihres Index im Muster identifiziert werden.

Non-Capturing Group: (?:...)

Stimmt mit einem Teilmuster überein, ohne Informationen über die Übereinstimmung zu speichern.

Unicode-Character-Class-Escape: \p{...}, \P{...}

Stimmt mit einer durch eine Unicode-Eigenschaft festgelegten Zeichenmenge überein. Wenn das Flag v aktiviert ist, können damit auch Zeichenfolgen endlicher Länge abgeglichen werden.

Wildcard: .

Stimmt mit jedem Zeichen außer Zeilenabschlusszeichen überein, sofern das Flag s nicht gesetzt ist.

Weitere Funktionen

Diese Funktionen legen selbst kein Muster fest, sondern dienen dazu, Muster zusammenzusetzen.

Disjunktion: |

Stimmt mit einer von mehreren Alternativen überein, die durch das Zeichen | getrennt sind.

Quantifier: *, +, ?, {n}, {n,}, {n,m}

Stimmt mit einem Atom überein, das eine bestimmte Anzahl von Malen vorkommt.

Escape-Sequenzen

Escape-Sequenzen in regulären Ausdrücken sind Syntaxformen, die aus \ gefolgt von einem oder mehreren Zeichen bestehen. Je nachdem, was auf \ folgt, können sie sehr unterschiedliche Zwecke erfüllen. Die folgende Tabelle führt alle gültigen Escape-Sequenzen auf:

Auf \ gefolgt von 0 und einer weiteren Ziffer folgt eine veraltete oktale Escape-Sequenz, die im Unicode-bewussten Modus verboten ist. Folgt auf \ eine andere Ziffernfolge, entsteht eine Backreference.

Außerdem können auf \ bestimmte Zeichen folgen, die weder Buchstaben noch Ziffern sind. In diesem Fall ist die Escape-Sequenz immer ein Character Escape, das für das escapte Zeichen selbst steht:

• \$, \(, \), \*, \+, \., \/, \?, \[, \\, \], \^, \{, \|, \}: überall gültig
• \-: nur innerhalb von Character Classes gültig
• \!, \#, \%, \&, \,, \:, \;, \<, \=, \>, \@, \`, \~: nur innerhalb von Character Classes im v-Modus gültig

Die übrigen ASCII-Zeichen – nämlich das Leerzeichen, ", ', _ sowie alle oben nicht genannten Buchstaben – bilden keine gültigen Escape-Sequenzen. Im Unicode-unbewussten Modus werden Escape-Sequenzen, die nicht zu den oben genannten gehören, zu Identity Escapes: Sie stehen für das Zeichen, das auf den Backslash folgt. Beispielsweise steht \a für das Zeichen a. Dieses Verhalten schränkt die Möglichkeit ein, neue Escape-Sequenzen einzuführen, ohne Probleme mit der Abwärtskompatibilität zu verursachen. Daher ist es im Unicode-bewussten Modus verboten.

Spezifikationen

Browser-Kompatibilität

Siehe auch

• Leitfaden zu regulären Ausdrücken
• RegExp