Reguläre Ausdrücke

Sie erstellen einen regulären Ausdruck auf zwei Arten:

• Mit einem regulären Ausdrucks-Literal, das aus einem zwischen Schrägstrichen eingeschlossenen Muster besteht, wie folgt:

  js

  const re = /ab+c/;
  

  Reguläre Ausdrucks-Literale bieten die Kompilierung des regulären Ausdrucks, wenn das Skript geladen wird. Wenn der reguläre Ausdruck konstant bleibt, kann dies die Leistung verbessern.

• Oder indem Sie die Konstruktorfunktion des RegExp Objekts aufrufen, wie folgt:

  js

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

  Die Verwendung der Konstruktorfunktion bietet die Kompilierung des regulären Ausdrucks zur Laufzeit. Verwenden Sie die Konstruktorfunktion, wenn Sie wissen, dass sich das Muster des regulären Ausdrucks ändern wird, oder wenn Sie das Muster nicht kennen und es aus einer anderen Quelle erhalten, wie zum Beispiel Nutzereingaben.

Ein reguläres Ausdrucksmuster besteht aus einfachen Zeichen, wie /abc/, oder einer Kombination aus einfachen und speziellen Zeichen, wie /ab*c/ oder /Chapter (\d+)\.\d*/. Das letzte Beispiel enthält Klammern, die als Gedächtnisstütze verwendet werden. Das mit diesem Teil des Musters gefundene Match wird für späteren Gebrauch gespeichert, wie im Abschnitt Verwendung von Gruppen beschrieben.

Einfache Muster bestehen aus Zeichen, für die Sie eine direkte Übereinstimmung finden möchten. Zum Beispiel stimmt das Muster /abc/ mit Zeichenkombinationen in Zeichenketten nur überein, wenn die genaue Sequenz "abc" vorkommt (alle Zeichen zusammen und in dieser Reihenfolge). Eine solche Übereinstimmung würde in den Zeichenketten "Hi, do you know your abc's?" und "The latest airplane designs evolved from slabcraft." erfolgreich sein. In beiden Fällen ist die Übereinstimmung mit dem Unterstring "abc". Es gibt keine Übereinstimmung in der Zeichenkette "Grab crab", denn obwohl sie den Unterstring "ab c" enthält, enthält sie nicht den exakten Unterstring "abc".

Wenn die Suche nach einer Übereinstimmung mehr erfordert als eine direkte Übereinstimmung, z. B. das Finden von einem oder mehreren Buchstaben "b" oder das Finden von Leerzeichen, können Sie spezielle Zeichen im Muster verwenden. Zum Beispiel, um eine einzelne "a" gefolgt von null oder mehr "b"s gefolgt von "c" zu finden, würden Sie das Muster /ab*c/ verwenden: das * nach "b" bedeutet "0 oder mehr Vorkommen des vorhergehenden Elements." In der Zeichenkette "cbbabbbbcdebc" wird dieses Muster den Unterstring "abbbbc" finden.

Die folgenden Seiten bieten Listen der verschiedenen speziellen Zeichen, die in jede Kategorie passen, zusammen mit Beschreibungen und Beispielen.

Assertions Leitfaden

Assertions enthalten Grenzen, die auf den Beginn und das Ende von Zeilen und Wörtern hinweisen, und andere Muster, die in irgendeiner Weise angeben, dass eine Übereinstimmung möglich ist (einschließlich Look-Ahead, Look-Behind und bedingte Ausdrücke).

Zeichenklassen Leitfaden

Unterscheiden verschiedene Arten von Zeichen. Beispielsweise Unterscheidung zwischen Buchstaben und Ziffern.

Gruppen und Rückverweise Leitfaden

Gruppen verbinden mehrere Muster als Ganzes, und erfassende Gruppen liefern zusätzliche Informationen über den Teilabgleich, wenn ein reguläres Ausdrucksmuster mit einer Zeichenkette abgeglichen wird. Rückverweise beziehen sich auf eine zuvor erfasste Gruppe im selben regulären Ausdruck.

Quantifizierer Leitfaden

Geben die Anzahl der Zeichen oder Ausdrücke an, die abgeglichen werden sollen.

Wenn Sie alle speziellen Zeichen, die in regulären Ausdrücken verwendet werden können, in einer einzigen Tabelle sehen möchten, schauen Sie sich folgendes an:

Note: Ein größeres Spickzettel ist ebenfalls verfügbar (das nur Teile dieser einzelnen Artikel zusammenfasst).

Wenn Sie eines der speziellen Zeichen wörtlich verwenden müssen (tatsächlich nach einem "*" suchen, zum Beispiel), müssen Sie es durch ein Voranstellen eines Backslashs escapen. Zum Beispiel, um nach "a" gefolgt von "*" gefolgt von "b" zu suchen, würden Sie /a\*b/ verwenden — der Backslash "escapt" das "*", sodass es wörtlich anstelle von speziell ist.

Ebenso, wenn Sie ein reguläres Ausdrucks-Literal schreiben und einen Schrägstrich ("/") abgleichen müssen, müssen Sie diesen escapen (andernfalls beendet er das Muster). Um beispielsweise nach der Zeichenkette "/example/" gefolgt von einem oder mehreren alphabetischen Zeichen zu suchen, würden Sie /\/example\/[a-z]+/i verwenden — die Backslashes vor jedem Schrägstrich machen sie wörtlich.

Um einen wörtlichen Backslash abzugleichen, müssen Sie den Backslash escapen. Zum Beispiel, um die Zeichenkette "C:\" zu finden, wobei "C" ein beliebiger Buchstabe sein kann, würden Sie /[A-Z]:\\/ verwenden — der erste Backslash escapt den danach, sodass der Ausdruck nach einem einzelnen wörtlichen Backslash sucht.

Wenn Sie den RegExp Konstruktor mit einem Zeichenkettenliteral verwenden, denken Sie daran, dass der Backslash in Zeichenkettenliteralen ein Escapezeichen ist, daher müssen Sie ihn auf Zeichenkettenliteralebene escapen, um ihn im regulären Ausdruck zu verwenden. /a\*b/ und new RegExp("a\\*b") erzeugen denselben Ausdruck, der nach "a" gefolgt von einem wörtlichen "*" gefolgt von "b" sucht.

Die RegExp.escape() Funktion gibt eine neue Zeichenkette zurück, bei der alle speziellen Zeichen der RegEx-Syntax escapt sind. Dies ermöglicht Ihnen new RegExp(RegExp.escape("a*b")), um einen regulären Ausdruck zu erstellen, der nur die Zeichenkette "a*b" abgleicht.

Klammern um einen beliebigen Teil des regulären Ausdrucksmusters bewirken, dass dieser Teil der gefundenen Teilzeichenkette gespeichert wird. Einmal gespeichert, kann die Teilzeichenkette für andere Zwecke erneut aufgerufen werden. Weitere Einzelheiten finden Sie unter Gruppen und Rückverweise.

Reguläre Ausdrücke werden mit den Methoden RegExp test() und exec() und mit den Methoden String match(), matchAll(), replace(), replaceAll(), search(), und split() verwendet.

Wenn Sie wissen möchten, ob ein Muster in einer Zeichenkette gefunden wird, verwenden Sie die test() oder search() Methoden; für mehr Informationen (jedoch langsamere Ausführung) verwenden Sie die exec() oder match() Methoden. Wenn Sie exec() oder match() verwenden und das Match erfolgreich ist, geben diese Methoden ein Array zurück und aktualisieren Eigenschaften des zugehörigen regulären Ausdrucksobjekts sowie des vordefinierten regulären Ausdrucksobjekts, RegExp. Wenn das Match fehlschlägt, gibt die exec() Methode null zurück (was zu false führt).

Im folgenden Beispiel verwendet das Skript die exec() Methode, um ein Match in einer Zeichenkette zu finden.

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

Wenn Sie nicht auf die Eigenschaften des regulären Ausdrucks zugreifen müssen, können Sie myArray auch mit diesem Skript erstellen:

const myArray = /d(b+)d/g.exec("cdbbdbsbz");
// similar to 'cdbbdbsbz'.match(/d(b+)d/g); however,
// 'cdbbdbsbz'.match(/d(b+)d/g) outputs [ "dbbd" ]
// while /d(b+)d/g.exec('cdbbdbsbz') outputs [ 'dbbd', 'bb', index: 1, input: 'cdbbdbsbz' ]

(Siehe Verwendung der globalen Suchmarkierung mit exec() für weitere Informationen über die unterschiedlichen Verhaltensweisen.)

Wenn Sie den regulären Ausdruck aus einer Zeichenkette konstruieren möchten, ist eine weitere Alternative dieses Skript:

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

Mit diesen Skripten ist der Match erfolgreich und gibt das Array zurück und aktualisiert die in der folgenden Tabelle gezeigten Eigenschaften.

Wie in der zweiten Form dieses Beispiels gezeigt, können Sie einen regulären Ausdruck mit einer Objektinitialisierung erstellen, ohne ihn einer Variablen zuzuweisen. Wenn Sie dies jedoch tun, ist jede Vorkommen ein neuer regulärer Ausdruck. Aus diesem Grund, wenn Sie diese Form ohne Zuordnung zu einer Variablen verwenden, können Sie anschließend nicht auf die Eigenschaften dieses regulären Ausdrucks zugreifen. Angenommen, Sie haben dieses Skript:

const myRe = /d(b+)d/g;
const myArray = myRe.exec("cdbbdbsbz");
console.log(`The value of lastIndex is ${myRe.lastIndex}`);

// "The value of lastIndex is 5"

Wenn Sie jedoch dieses Skript haben:

const myArray = /d(b+)d/g.exec("cdbbdbsbz");
console.log(`The value of lastIndex is ${/d(b+)d/g.lastIndex}`);

// "The value of lastIndex is 0"

Die Vorkommen von /d(b+)d/g in den beiden Anweisungen sind verschiedene reguläre Ausdrucksobjekte und haben daher unterschiedliche Werte für ihre lastIndex-Eigenschaft. Wenn Sie auf die Eigenschaften eines regulären Ausdrucks zugreifen müssen, der mit einem Objektinitialisierer erstellt wurde, sollten Sie ihn zuerst einer Variablen zuweisen.

Reguläre Ausdrücke haben optionale Markierungen, die Funktionen wie globales Suchen und Groß-/Kleinschreibung ignorierendes Suchen ermöglichen. Diese Markierungen können separat oder zusammen in beliebiger Reihenfolge verwendet werden und sind ein Teil des regulären Ausdrucks.

Um eine Markierung mit dem regulären Ausdruck einzuschließen, verwenden Sie diese Syntax:

const re = /pattern/flags;

oder

const re = new RegExp("pattern", "flags");

Beachten Sie, dass die Markierungen ein integraler Bestandteil eines regulären Ausdrucks sind. Sie können nicht später hinzugefügt oder entfernt werden.

Zum Beispiel, re = /\w+\s/g erstellt einen regulären Ausdruck, der nach einem oder mehreren Zeichen gefolgt von einem Leerzeichen sucht und diese Kombination in der gesamten Zeichenkette sucht.

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

// ["fee ", "fi ", "fo "]

Sie könnten die Zeile ersetzen:

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

mit:

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

und das gleiche Ergebnis erhalten.

Die m Markierung wird verwendet, um anzugeben, dass eine mehrzeilige Eingabezeichenkette als mehrere Zeilen behandelt werden sollte. Wenn die m Markierung verwendet wird, stimmen ^ und $ am Anfang oder Ende einer beliebigen Zeile innerhalb der Eingabezeichenkette überein, anstatt am Anfang oder Ende der gesamten Zeichenkette.

Die i, m, und s Markierungen können für spezifische Teile einer Regex mithilfe der Modifier-Syntax aktiviert oder deaktiviert werden.

Verwendung der globalen Suchmarkierung mit exec()

RegExp.prototype.exec() Methode mit der g Markierung gibt jedes Match und dessen Position iterativ zurück.

const str = "fee fi fo fum";
const re = /\w+\s/g;

console.log(re.exec(str)); // ["fee ", index: 0, input: "fee fi fo fum"]
console.log(re.exec(str)); // ["fi ", index: 4, input: "fee fi fo fum"]
console.log(re.exec(str)); // ["fo ", index: 7, input: "fee fi fo fum"]
console.log(re.exec(str)); // null

Im Gegensatz dazu gibt die String.prototype.match() Methode alle Übereinstimmungen auf einmal zurück, jedoch ohne deren Position.

console.log(str.match(re)); // ["fee ", "fi ", "fo "]

Verwendung von Unicode-regulären Ausdrücken

Die u Markierung wird verwendet, um "Unicode"-reguläre Ausdrücke zu erstellen; das heißt, reguläre Ausdrücke, die das Abgleichen gegen Unicode-Text unterstützen. Ein wichtiges Feature, das im Unicode-Modus aktiviert wird, sind Unicode-Eigenschaftsentsprechungen. Zum Beispiel könnte der folgende reguläre Ausdruck verwendet werden, um gegen ein beliebiges Unicode-"Wort" zu matchen:

/\p{L}*/u;

Unicode-reguläre Ausdrücke haben auch unterschiedliches Verhalten bei der Ausführung. RegExp.prototype.unicode enthält weitere Erklärungen dazu.

Im folgenden Beispiel soll der Benutzer eine Telefonnummer eingeben. Wenn der Benutzer die Schaltfläche "Prüfen" drückt, überprüft das Skript die Gültigkeit der Nummer. Wenn die Nummer gültig ist (der Zeichenfolge entspricht, die im regulären Ausdruck angegeben ist), zeigt das Skript eine Nachricht, die dem Benutzer dankt und die Nummer bestätigt. Wenn die Nummer ungültig ist, informiert das Skript den Benutzer, dass die Telefonnummer ungültig ist.

Der reguläre Ausdruck sucht nach:

1. dem Anfang der Zeile der Daten: ^
2. gefolgt von drei numerischen Zeichen \d{3} ODER | einer linken Klammer \(, gefolgt von drei Ziffern \d{3}, gefolgt von einer rechten Klammer \), in einer nicht-erfassenden Gruppe (?:)
3. gefolgt von einem Bindestrich, Schrägstrich oder Dezimalpunkt in einer erfassenden Gruppe ()
4. gefolgt von drei Ziffern \d{3}
5. gefolgt von dem Match, das in der (ersten) erfassten Gruppe gespeichert ist \1
6. gefolgt von vier Ziffern \d{4}
7. gefolgt vom Ende der Zeile der Daten: $

HTML

<p>
  Enter your phone number (with area code) and then click "Check".
  <br />
  The expected format is like ###-###-####.
</p>
<form id="form">
  <input id="phone" />
  <button type="submit">Check</button>
</form>
<p id="output"></p>

JavaScript

const form = document.querySelector("#form");
const input = document.querySelector("#phone");
const output = document.querySelector("#output");

const re = /^(?:\d{3}|\(\d{3}\))([-/.])\d{3}\1\d{4}$/;

function testInfo(phoneInput) {
  const ok = re.exec(phoneInput.value);

  output.textContent = ok
    ? `Thanks, your phone number is ${ok[0]}`
    : `${phoneInput.value} isn't a phone number with area code!`;
}

form.addEventListener("submit", (event) => {
  event.preventDefault();
  testInfo(input);
});

Ergebnis

RegExr

Ein Online-Tool zum Lernen, Erstellen und Testen von Regulären Ausdrücken.

Regex Tester

Ein Online-Builder/Debugger für Regex

Regex interaktives Tutorial

Ein Online-Interaktives Tutorial, Spickzettel, & Spielwiese.

Regex-Visualizer

Ein Online-Visual-Tester für Regex.

• Zurück
• Weiter