Reguläre Ausdrücke

Sie erstellen einen regulären Ausdruck auf eine von zwei Arten:

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

  js

  const re = /ab+c/;
  

  Reguläre Ausdruck-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 durch Aufrufen der Konstruktorfunktion des RegExp-Objekts, wie folgt:

  js

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

  Die Verwendung der Konstruktorfunktion bietet 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 Benutzereingaben, erhalten.

Ein regulärer Ausdruck 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. Die Übereinstimmung mit diesem Teil des Musters wird für die spätere Verwendung gespeichert, wie im Abschnitt Gruppen verwenden beschrieben.

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

Wenn die Suche nach einer Übereinstimmung mehr als eine direkte Übereinstimmung erfordert, wie das Finden von einem oder mehreren 'b's oder das Finden von Leerzeichen, können Sie spezielle Zeichen im Muster verwenden. Zum Beispiel, um 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 vorhergehenden Elements“. In der Zeichenkette "cbbabbbbcdebc" passt dieses Muster mit der Teilzeichenfolge "abbbbc".

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

Assertions Leitfaden

Assertions beinhalten Grenzen, die Anfänge und Enden von Zeilen und Wörtern anzeigen, sowie andere Muster, die auf irgendeine Weise anzeigen, dass eine Übereinstimmung möglich ist (einschließlich Look-Ahead, Look-Behind und bedingten Ausdrücken).

Zeichenklassen Leitfaden

Unterscheidung verschiedener Zeichentypen. Zum Beispiel die Unterscheidung zwischen Buchstaben und Ziffern.

Gruppen und Rückverweise Leitfaden

Gruppen gruppieren mehrere Muster als Ganzes, und Erfassungsgruppen liefern zusätzliche Informationen zum Teilabgleich, wenn ein reguläres Ausdrucksmuster zum Abgleich mit einer Zeichenkette verwendet wird. Rückverweise beziehen sich auf eine zuvor erfaßte Gruppe im gleichen regulären Ausdruck.

Quantoren 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 Tabelle sehen möchten, siehe folgendes:

Note: Ein ausführlicheres Cheat Sheet steht ebenfalls zur Verfügung (das nur Teile dieser einzelnen Artikel zusammenfasst).

Wenn Sie eines der Sonderzeichen im wörtlichen Sinne verwenden müssen (tatsächlich nach einem "*" suchen, zum Beispiel), müssen Sie es mit einem Backslash davor maskieren. Um beispielsweise nach "a" gefolgt von "*" gefolgt von "b" zu suchen, würden Sie /a\*b/ verwenden — der Backslash "maskiert" das "*", was es wörtlich anstatt speziell macht.

Ähnlich, wenn Sie ein reguläres Ausdruck-Literal schreiben und einen Schrägstrich ("/") abgleichen müssen, müssen Sie diesen maskieren (sonst beendet er das Muster). Um beispielsweise nach der Zeichenfolge "/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 zu markieren, müssen Sie den Backslash maskieren. Zum Beispiel, um die Zeichenkette "C:\" zu markieren, wo "C" beliebig sein kann, würden Sie /[A-Z]:\\/ verwenden — der erste Backslash maskiert den, der ihm folgt, sodass der Ausdruck nach einem einzigen wörtlichen Backslash sucht.

Wenn Sie den RegExp-Konstruktor mit einem Zeichenfolgenliteral verwenden, denken Sie daran, dass der Backslash eine Escape-Sequenz in Zeichenfolgenliteralen darstellt. Um ihn im regulären Ausdruck zu verwenden, müssen Sie ihn 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 Zeichenkette zurück, in der alle Sonderzeichen in der Regex-Syntax maskiert sind. Dies ermöglicht Ihnen, new RegExp(RegExp.escape("a*b")) zu verwenden, um einen regulären Ausdruck zu erstellen, der nur die Zeichenkette "a*b" markiert.

Klammern um einen beliebigen Teil des regulären Ausdrucksmusters bewirken, dass dieser Teil der übereinstimmenden Teilzeichenfolge gemerkt wird. Sobald gemerkt, kann die Teilzeichenfolge für andere Zwecke wiederverwendet werden. Weitere Details finden Sie unter Gruppen und Rückverweise verwenden.

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 Methoden test() oder search(); für mehr Informationen (aber langsamerer Ausführung) verwenden Sie die Methoden exec() oder match(). Wenn Sie exec() oder match() verwenden und 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 Methode exec() null zurück (was zu false wird).

Im folgenden Beispiel verwendet das Skript die Methode exec(), 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 zu erstellen, mit diesem Skript:

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 Globale Suchflagge mit exec() verwenden für weitere Informationen zu den 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 die Übereinstimmung erfolgreich und gibt das Array zurück und aktualisiert die in der folgenden Tabelle gezeigten Eigenschaften.

Wie im zweiten Formular dieses Beispiels gezeigt, können Sie einen regulären Ausdruck, der mit einem Objektinitialisierer erstellt wurde, ohne ihn einer Variablen zuzuweisen, verwenden. Wenn Sie dies jedoch tun, ist jedes Vorkommen ein neuer regulärer Ausdruck. Aus diesem Grund können Sie, wenn Sie diese Form verwenden, ohne sie einer Variablen zuzuweisen, nicht mehr 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 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, das mit einem Objektinitialisierer erstellt wurde, sollten Sie es zuerst einer Variablen zuweisen.

Reguläre Ausdrücke haben optionale Flags, mit denen Funktionen wie globales Suchen und fallunabhängiges Suchen möglich sind. Diese Flags können einzeln oder zusammen in beliebiger Reihenfolge verwendet werden und sind Teil des regulären Ausdrucks.

Um ein Flag 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 Flags ein integraler Bestandteil eines regulären Ausdrucks sind. Sie können später nicht hinzugefügt oder entfernt werden.

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

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 Eingabezeichenkette als mehrere Zeilen behandelt werden soll. Wenn das m-Flag verwendet wird, stimmen ^ und $ am Beginn oder Ende einer beliebigen Zeile innerhalb der Eingabezeichenkette anstelle des Beginns oder Endes der gesamten Zeichenkette überein.

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

Verwendung des globalen Suchflags mit exec()

Die RegExp.prototype.exec()-Methode mit dem g-Flag gibt jede Übereinstimmung und ihre 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; das heißt, reguläre Ausdrücke, die das Übereinstimmen mit Unicode-Text unterstützen. Ein wichtiges Feature, das im Unicode-Modus aktiviert ist, sind Unicode-Eigenschafts-Escapes. Zum Beispiel könnte der folgende reguläre Ausdruck verwendet werden, um gegen ein beliebiges Unicode-"Wort" zu prüfen:

/\p{L}*/u;

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

Im folgenden Beispiel wird vom Benutzer erwartet, eine Telefonnummer einzugeben. Wenn der Benutzer auf die Schaltfläche "Prüfen" drückt, überprüft das Skript die Gültigkeit der Nummer. Wenn die Nummer gültig ist (mit der durch den regulären Ausdruck angegebenen Zeichenfolge übereinstimmt), zeigt das Skript eine Nachricht an, die dem Benutzer dankt und die Nummer bestätigt. Wenn die Nummer ungültig ist, informiert das Skript den Benutzer darüber, dass die Telefonnummer nicht gültig ist.

Der reguläre Ausdruck sucht nach:

1. dem Beginn der Datenzeile: ^
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 Strich, Schrägstrich oder Dezimalpunkt in einer erfassenden Gruppe ()
4. gefolgt von drei Ziffern \d{3}
5. gefolgt von der in der (ersten) Gruppe erfassten Übereinstimmung \1
6. gefolgt von vier Ziffern \d{4}
7. gefolgt vom 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-Builder/Debugger

Regex interaktives Tutorial

Ein Online-Interaktives Tutorial, Cheat Sheet und Playground.

Regex-Visualizer

Ein Online-Visual-RegEx-Tester.

• Zurück
• Weiter