Reguläre Ausdrücke

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

• Verwenden eines regulären Ausdrucksliterals, 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. Bleibt der reguläre Ausdruck konstant, 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 ermöglicht die Laufzeitkompilierung des regulären Ausdrucks. Verwenden Sie die Konstruktorfunktion, wenn Sie wissen, dass sich das Muster des regulären Ausdrucks ändert, oder wenn Sie das Muster aus einer anderen Quelle erhalten, zum Beispiel aus Benutzereingaben.

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. Der mit diesem Teil des Musters gemachte Treffer wird für eine spätere Verwendung gespeichert, wie in 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 Zeichenfolgen überein, wenn die genaue Sequenz "abc" vorkommt (alle Zeichen zusammen und in dieser Reihenfolge). Eine solche Übereinstimmung würde in den Zeichenfolgen "Hi, do you know your abc's?" und "The latest airplane designs evolved from slabcraft." erfolgreich sein. In beiden Fällen stimmt die Übereinstimmung mit dem Teilstring "abc" überein. Keine Übereinstimmung gibt es in der Zeichenfolge "Grab crab", da sie zwar den Teilstring "ab c" enthält, aber nicht den genauen Teilstring "abc".

Wenn die Suche nach einer Übereinstimmung mehr als eine direkte Übereinstimmung erfordert, wie z.B. das Finden eines oder mehrerer "b" oder das Finden von Leerzeichen, können Sie spezielle Zeichen im Muster einfügen. Um ein einziges "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 Zeichenfolge "cbbabbbbcdebc" wird dieses Muster den Teilstring "abbbbc" finden.

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

Assertions Leitfaden

Assertions umfassen Grenzen, die den Beginn und das Ende 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

Unterscheiden zwischen verschiedenen Arten von Zeichen. Zum Beispiel zwischen Buchstaben und Ziffern unterscheiden.

Gruppen und Rückverweise Leitfaden

Gruppen fassen mehrere Muster als Ganzes zusammen, und Capturing-Gruppen bieten zusätzliche Unterübereinstimmungsinformationen, wenn ein reguläres Ausdrucksmuster verwendet wird, um mit einer Zeichenfolge zu übereinstimmen. Rückverweise beziehen sich auf eine zuvor erfasste Gruppe im selben regulären Ausdruck.

Quantifizierer Leitfaden

Gibt die Anzahl der zu suchenden Zeichen oder Ausdrücke an.

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

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

Wenn Sie eines der speziellen Zeichen wörtlich verwenden müssen (tatsächlich nach einem * suchen, zum Beispiel), müssen Sie es mit einem Backslash davor maskieren. Um z.B. nach "a" gefolgt von "*" gefolgt von "b" zu suchen, würden Sie /a\*b/ verwenden – der Backslash „maskiert“ das *, wodurch es wörtlich anstelle von 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). Um z.B. 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 abzugleichen, müssen Sie den Backslash maskieren. Um z.B. die Zeichenfolge "C:\" abzugleichen, wobei "C" ein beliebiger Buchstabe sein kann, würden Sie /[A-Z]:\\/ verwenden — der erste Backslash maskiert den danach, 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 in Zeichenfolgenliteralen als Escapezeichen dient. Um ihn daher im regulären Ausdruck zu verwenden, müssen Sie ihn auf der Ebene des Zeichenfolgenliterals maskieren. /a\*b/ und new RegExp("a\\*b") erstellen den gleichen Ausdruck, der nach „a“ gefolgt von einem wörtlichen \* gefolgt von „b“ sucht.

Die Funktion RegExp.escape() gibt einen neuen Zeichenfolgenwert zurück, bei dem alle speziellen Zeichen in der Regex-Syntax maskiert sind. Mit dieser Funktion können Sie z.B. 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 regulären Ausdrucksmusters bewirken, dass dieser Teil des übereinstimmenden Teilstrings gespeichert wird. Sobald gespeichert, kann der Teilstring für andere Verwendungen abgerufen werden. Siehe Gruppen und Rückverweise für weitere Details.

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

Wenn Sie wissen möchten, ob ein Muster in einer Zeichenfolge gefunden wird, verwenden Sie die Methoden test() oder search(); für mehr Informationen (aber langsamer in der 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 exec()-Methode null zurück (was sich zu false auswertet).

Im folgenden Beispiel verwendet das Skript die exec()-Methode, um eine Übereinstimmung in einer Zeichenfolge 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 zur Erstellung von myArray dieses 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 Verwendung des globalen Suchflags mit exec() für weitere Informationen über die verschiedenen Verhaltensweisen.)

Wenn Sie den regulären Ausdruck aus einer Zeichenfolge 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 gelingt die Übereinstimmung 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, der mit einem Objektinitialisierer erstellt wurde, verwenden, ohne ihn einer Variablen zuzuweisen. Wenn Sie dies jedoch tun, ist jedes Vorkommen ein neuer regulärer Ausdruck. Aus diesem Grund können Sie auf die Eigenschaften dieses regulären Ausdrucks nicht zugreifen, wenn Sie diese Form ohne Zuweisung zu einer Variablen verwenden. Nehmen wir an, 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"

Sind die Vorkommen von /d(b+)d/g in den beiden Anweisungen 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 Flags, die eine Funktionalität wie globale Suche und nichtgeschäftsabhängige Suche ermöglichen. Diese Flags können separat oder zusammen in beliebiger Reihenfolge verwendet werden und sind Teil des regulären Ausdrucks.

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 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 diese Kombination in der gesamten Zeichenfolge.

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:

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

ersetzen mit:

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

und dasselbe Ergebnis erzielen.

Das m-Flag wird verwendet, um anzugeben, dass eine mehrzeilige Eingabezeichenfolge als mehrere Zeilen behandelt werden sollte. Wenn das m-Flag verwendet wird, stimmt ^ und $ beim Start oder Ende einer Zeile innerhalb der Eingabezeichenfolge überein, anstatt am Start oder Ende der gesamten Zeichenfolge.

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

Verwendung des globalen Suchflags mit exec()

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 ihre Position.

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

Verwendung von Unicode-Regulärausdrücken

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

/\p{L}*/u;

Unicode-Regulärausdrücke haben ebenfalls ein anderes Ausführungsverhalten. RegExp.prototype.unicode enthält weitere Erklärungen dazu.

Im folgenden Beispiel wird vom Benutzer erwartet, eine Telefonnummer einzugeben. Wenn der Benutzer auf die Schaltfläche "Prüfen" klickt, überprüft das Skript die Gültigkeit der Nummer. Wenn die Nummer gültig ist (mit der von der regulären Ausdruck bestimmten Zeichenfolge übereinstimmt), zeigt das Skript eine Nachricht an, in der sich der Benutzer bedankt 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 Datenzeile: ^
2. gefolgt von drei numerischen Zeichen \d{3} ODER | eine öffnende Klammer \(, gefolgt von drei Ziffern \d{3}, gefolgt von einer schließenden Klammer \), in einer nicht erfassten Gruppe (?:)
3. gefolgt von einem Strich, Schrägstrich oder Dezimalpunkt in einer erfassten Gruppe ()
4. gefolgt von drei Ziffern \d{3}
5. gefolgt von dem in der (ersten) erfassten Gruppe gespeicherten Treffer \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, Spickzettel und Playground.

Regex-Visualizer

Ein Online-Visualizer für reguläre Ausdrücke.

• Zurück
• Weiter