Reguläre Ausdrücke

Sie können einen regulären Ausdruck auf zwei Arten erstellen:

• Mit einem regulären Ausdrucksliteral, das aus einem Muster besteht, das zwischen Schrägstrichen eingeschlossen ist, wie folgt:

  js

  const re = /ab+c/;
  

  Reguläre Ausdrucksliterale ermöglichen die Kompilierung des regulären Ausdrucks, wenn das Skript geladen wird. Wenn der reguläre Ausdruck konstant bleibt, kann dies die Leistung verbessern.

• Oder durch Aufrufen der Konstruktorfunktion des RegExp-Objekts, wie folgt:

  js

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

  Die Verwendung der Konstruktorfunktion ermöglicht die Laufzeitkompilierung des regulären Ausdrucks. 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, wie z.B. Benutzereingaben, erhalten.

Ein reguläres Ausdrucksmuster besteht aus einfachen Zeichen, wie /abc/, oder aus einer Kombination von einfachen und Sonderzeichen, wie /ab*c/ oder /Chapter (\d+)\.\d*/. Das letzte Beispiel enthält Klammern, die als Erinnerungsvorrichtung verwendet werden. Das Muster, das mit diesem Teil des Musters übereinstimmt, wird für die spätere Verwendung 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/ nur dann mit Zeichenkombinationen in Zeichenketten überein, wenn die genaue Folge "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 erfolgt die Übereinstimmung mit der Teilzeichenkette "abc". Es gibt keine Übereinstimmung in der Zeichenkette "Grab crab", da sie zwar die Teilzeichenkette "ab c" enthält, jedoch nicht die exakte Teilzeichenkette "abc".

Wenn die Suche nach einer Übereinstimmung mehr als eine direkte Übereinstimmung erfordert, wie z.B. das Finden von einem oder mehreren bs oder das Finden von Leerzeichen, können Sie Sonderzeichen im Muster einfügen. Um beispielsweise ein einzelnes "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 vorherigen Elements". In der Zeichenkette "cbbabbbbcdebc" wird dieses Muster mit der Teilzeichenkette "abbbbc" übereinstimmen.

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

Assertions Leitfaden

Assertions beinhalten Grenzen, die den Anfang und das Ende von Zeilen und Wörtern angeben, und andere Muster, die auf irgendeine Weise anzeigen, dass eine Übereinstimmung möglich ist (einschließlich Look-Ahead, Look-Behind und konditionalen Ausdrücken).

Zeichenklassen Leitfaden

Unterscheidet verschiedene Arten von Zeichen. Beispielsweise die Unterscheidung zwischen Buchstaben und Ziffern.

Gruppen und Rückverweise Leitfaden

Gruppen fassen mehrere Muster als Ganzes zusammen, und erfassende Gruppen liefern zusätzliche Teilübereinstimmungsinformationen, wenn ein regulärer Ausdruck verwendet wird, um gegen eine Zeichenkette abzugleichen. Rückverweise beziehen sich auf eine zuvor erfasste Gruppe im selben regulären Ausdruck.

Quantifizierer Leitfaden

Geben die Anzahl der zu vergleichenden Zeichen oder Ausdrücke an.

Wenn Sie alle Sonderzeichen, die in regulären Ausdrücken verwendet werden können, in einer einzigen Tabelle betrachten möchten, sehen Sie sich Folgendes an:

Wenn Sie eines der Sonderzeichen wörtlich verwenden müssen (zum Beispiel tatsächlich nach einem "*" suchen), sollten Sie es maskieren, indem Sie einen Backslash davor setzen. Zum Beispiel, um nach "a" gefolgt von "*" gefolgt von "b" zu suchen, würden Sie /a\*b/ verwenden — der Backslash "maskiert" das "*", wodurch es wörtlich statt speziell wird.

Ähnlich, wenn Sie ein reguläres Ausdrucksliteral schreiben und einen Schrägstrich ("/") abgleichen müssen, müssen Sie diesen maskieren (ansonsten beendet er das Muster). Zum Beispiel, um nach dem Zeichenfolgen "/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 maskieren. Zum Beispiel, um nach der Zeichenkette "C:\" zu suchen, wobei "C" ein beliebiger Buchstabe sein kann, würden Sie /[A-Z]:\\/ verwenden — der erste Backslash maskiert den, der danach kommt, sodass der Ausdruck nach einem einzelnen wörtlichen Backslash sucht.

Wenn Sie den RegExp-Konstruktor mit einem Zeichenfolgenliteral verwenden, denken Sie daran, dass der Backslash ein Fluchtsymbol in Zeichenfolgenliteralen ist, also müssen Sie ihn im regulären Ausdruck auf der Ebene des Zeichenfolgenliterals maskieren. /a\*b/ und new RegExp("a\\*b") erstellen denselben Ausdruck, der nach "a" gefolgt von einem wörtlichen "*" gefolgt von "b" sucht.

Die Funktion RegExp.escape() gibt eine neue Zeichenfolge zurück, bei der alle Sonderzeichen in der Regex-Syntax maskiert sind. Damit können Sie new RegExp(RegExp.escape("a*b")) verwenden, um einen regulären Ausdruck zu erstellen, der nur die Zeichenfolge "a*b" abgleicht.

Klammern um einen beliebigen Teil des Musters des regulären Ausdrucks bewirken, dass dieser Teil des übereinstimmenden Substrings gespeichert wird. Einmal gespeichert, kann der Substring für andere Verwendungen abgerufen werden. Weitere Details finden Sie unter Gruppen und Rückverweise.

Reguläre Ausdrücke werden mit den RegExp-Methoden test() und exec() sowie mit den String-Methoden 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 (aber langsamere Ausführung) verwenden Sie die exec()- oder match()-Methoden. Wenn Sie exec() oder match() verwenden und wenn die Übereinstimmung erfolgreich ist, geben diese Methoden ein Array zurück und aktualisieren die Eigenschaften des zugehörigen regulären Ausdrucksobjekts sowie des vordefinierten regulären Ausdrucksobjekts RegExp. Wenn die Übereinstimmung fehlschlägt, gibt die exec()- Methode null zurück (was zu false wird).

Im folgenden Beispiel verwendet das Skript die exec()-Methode, um eine Übereinstimmung 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, ist eine alternative Möglichkeit, myArray mit diesem Skript zu 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 des globalen Suchflags mit exec() für weitere Informationen zu den unterschiedlichen Verhaltensweisen.)

Wenn Sie den regulären Ausdruck aus einer Zeichenkette erstellen 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 die Übereinstimmung erfolgreich und gibt das Array zurück und aktualisiert die in der folgenden Tabelle gezeigten Eigenschaften.

Wie im zweiten Form dieses Beispiels gezeigt, können Sie einen regulären Ausdruck, der mit einem Objektinitialisierer erstellt wurde, ohne Zuweisung zu einer Variablen verwenden. Wenn Sie dies jedoch tun, ist jede Vorkommen ein neuer regulärer Ausdruck. Deshalb, wenn Sie diese Form ohne Zuweisung zu einer Variablen verwenden, können Sie die Eigenschaften dieses regulären Ausdrucks nicht nachträglich 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 unterschiedliche 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 Flags, die Funktionalität wie globale Suche und suche ohne Berücksichtigung der Groß- und Kleinschreibung ermöglichen. Diese Flags können getrennt oder zusammen in beliebiger Reihenfolge verwendet werden und sind als Teil des regulären Ausdrucks enthalten.

Um ein Flag in den regulären Ausdruck aufzunehmen, verwenden Sie diese Syntax:

const re = /pattern/flags;

oder

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

Beachten Sie, dass die Flags 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 im gesamten String 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.

Das m-Flag wird verwendet, um anzugeben, dass eine mehrzeilige Eingabezeichenfolge als mehrere Zeilen betrachtet werden soll. Wenn das m-Flag verwendet wird, stimmen ^ und $ am Anfang oder Ende einer beliebigen Zeile innerhalb der Eingabezeichenfolge überein, anstatt am Anfang oder Ende des gesamten Strings.

Die Flags i, m und s können für bestimmte Teile eines Regex mit der Modifiersyntax aktiviert oder deaktiviert werden.

Verwendung des globalen Suchflags mit exec()

RegExp.prototype.exec()-Methode mit dem g-Flag gibt jede Übereinstimmung und deren 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

Das u-Flag wird verwendet, um "Unicode"-reguläre Ausdrücke zu erstellen, d.h. reguläre Ausdrücke, die das Abgleichen mit Unicode-Text unterstützen. Eine wichtige Funktion, die im Unicode-Modus aktiviert ist, sind Unicode-Eigenschaftsfluchten. Zum Beispiel könnte der folgende reguläre Ausdruck verwendet werden, um gegen ein beliebiges Unicode-"Wort" abzugleichen:

/\p{L}*/u;

Unicode-reguläre Ausdrücke haben auch anderes Ausführungsverhalten. RegExp.prototype.unicode enthält mehr Erklärungen dazu.

Im folgenden Beispiel wird vom Benutzer erwartet, eine Telefonnummer einzugeben. 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 (die Zeichenfolge, die durch den regulären Ausdruck angegeben wird, übereinstimmt), zeigt das Skript eine Nachricht an, in der dem Benutzer gedankt und die Nummer bestätigt wird. Wenn die Nummer ungültig ist, teilt das Skript dem Benutzer mit, dass die Telefonnummer nicht gültig ist.

Der reguläre Ausdruck sucht nach:

1. dem Anfang der Datenzeile: ^
2. gefolgt von drei numerischen Zeichen \d{3} ODER | einer linken Klammer \(, gefolgt von drei Ziffern \d{3}, gefolgt von einer schließenden 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 der Übereinstimmung der (ersten) eingefangenen Gruppe \1
6. gefolgt von vier Ziffern \d{4}
7. gefolgt von dem Ende der Datenzeile: $

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-Regex-Ersteller/Debug-Tool

Regex interaktives Tutorial

Ein Online-interaktives Tutorial, Spickzettel und Spielplatz.

Regex-Visualizer

Ein Online-Visual-Regex-Tester.

• Zurück
• Weiter