Regular expressions

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

• 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 die Verwendung dessen 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 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 beziehen, wie z.B. 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. Das mit diesem Teil des Musters gefundene Übereinstimmung wird wie im Artikel Verwendung von Gruppen beschrieben für die spätere Verwendung gespeichert.

Einfache Muster bestehen aus Zeichen, für die eine direkte Übereinstimmung gefunden werden soll. Beispielsweise stimmt das Muster /abc/ nur mit Zeichenkombinationen in Zeichenketten überein, wenn die exakte Folge "abc" auftritt (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 Teilstring "abc". Es gibt keine Übereinstimmung in der Zeichenkette "Grab crab", da sie zwar den Teilstring "ab c" enthält, jedoch nicht den exakten Teilstring "abc".

Wenn die Suche nach einer Übereinstimmung mehr als eine direkte Übereinstimmung erfordert, wie z.B. das Finden eines oder mehrerer bs oder das Finden von Leerzeichen, können spezielle Zeichen in das Muster aufgenommen werden. 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" würde 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 Begrenzungen, 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 bedingte Ausdrücke).

Zeichenklassen-Leitfaden

Unterscheiden verschiedene Arten von Zeichen. Zum Beispiel wird zwischen Buchstaben und Ziffern unterschieden.

Gruppen und Rückverweise-Leitfaden

Gruppen gruppieren mehrere Muster als Ganzes, und erfassende Gruppen liefern zusätzliche Submatch-Informationen, wenn ein reguläres Ausdrucksmuster mit einer Zeichenkette verglichen wird. Rückverweise beziehen sich auf eine zuvor erfasste Gruppe im gleichen regulären Ausdruck.

Quantifizierer-Leitfaden

Geben die Anzahl von Zeichen oder Ausdrücken an, die übereinstimmen sollen.

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

Wenn Sie eines der speziellen Zeichen wörtlich verwenden müssen (tatsächlich nach einem "*" suchen, zum Beispiel), müssen Sie es durch ein Backslash davor maskieren. Zum Beispiel, um nach "a" gefolgt von "*" gefolgt von "b" zu suchen, würden Sie /a\*b/ verwenden — der Backslash "maskiert" das "*", macht es wörtlich anstatt speziell.

Ebenso, wenn Sie ein reguläres Ausdrucksliteral schreiben und einen Schrägstrich ("/") übereinstimmen müssen, müssen Sie diesen maskieren (ansonsten beendet er das Muster). Zum Beispiel, um nach dem String "/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 diese wörtlich.

Um ein wörtliches Backslash zu maskieren, müssen Sie das Backslash maskieren. Zum Beispiel, um den String "C:\" zu maskieren, bei dem "C" jeder Buchstabe sein kann, würden Sie /[A-Z]:\\/ verwenden — der erste Backslash maskiert den nachfolgenden, sodass der Ausdruck nach einem einzigen wörtlichen Backslash sucht.

Wenn Sie den RegExp-Konstruktor mit einem Zeichenkettliteral verwenden, bedenken Sie, dass das Backslash ein Maskierungselement in Zeichenkettenliteralen ist. Um es im regulären Ausdruck zu verwenden, müssen Sie es auf der Ebene des Zeichenkettenliterals maskieren. /a\*b/ und new RegExp("a\\*b") erstellen denselben Ausdruck, der nach "a" gefolgt von einem wörtlichen "*" gefolgt von "b" sucht.

Wenn Escape-Zeichen nicht bereits Teil Ihres Musters sind, können Sie sie mit String.prototype.replace() hinzufügen:

function escapeRegExp(string) {
  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
}

Das "g" nach dem regulären Ausdruck ist eine Option oder Flag, die eine globale Suche durchführt, die in der gesamten Zeichenkette sucht und alle Übereinstimmungen zurückgibt. Es wird im Folgenden detailliert in Erweiterte Suche mit Flags erläutert.

Warum ist dies nicht in JavaScript eingebaut? Es gibt einen Vorschlag, eine solche Funktion zu RegExp hinzuzufügen.

Klammern um einen beliebigen Teil des regulären Ausdrucksmusters verursachen, dass dieser Teil des übereinstimmenden Teilstrings gespeichert wird. Sobald es gespeichert ist, kann der Teilstring zu einem späteren Zeitpunkt wiederverwendet werden. Siehe Gruppen und Rückverweise für mehr Details.

Reguläre Ausdrücke werden mit den RegExp-Methoden test() und exec() und 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 die Übereinstimmung erfolgreich ist, geben diese Methoden ein Array zurück und aktualisieren die Eigenschaften des zugehörigen regulären Ausdrucksobjekts und auch des vordefinierten regulären Ausdrucksobjekts RegExp. Wenn die Übereinstimmung fehlschlägt, gibt die exec()-Methode null zurück (was in false umgewandelt 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 die Eigenschaften des regulären Ausdrucks nicht benötigen, 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 Such-Flags mit exec() für weitere Informationen über die 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 Eigenschaften, die in der folgenden Tabelle gezeigt werden.

Wie im zweiten Teil dieses Beispiels gezeigt, können Sie einen regulären Ausdruck mit einem Objektinitialisierer erstellen, ohne ihn einer Variablen zuzuweisen. Wenn Sie dies tun, jedoch, ist jede Vorkommen ein neuer regulärer Ausdruck. Aus diesem Grund, wenn Sie diese Form verwenden, ohne sie einer Variablen zuzuweisen, können Sie nicht anschließend auf die Eigenschaften dieses regulären Ausdrucks zugreifen. Zum Beispiel, nehmen Sie 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"

Jedoch, wenn Sie 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 mit einem Objektinitialisierer erstellten regulären Ausdrucks zugreifen müssen, sollten Sie ihn zuerst einer Variablen zuweisen.

Reguläre Ausdrücke haben optionale Flags, die Funktionalitäten wie globale Suche und Groß-/Kleinschreibung ermöglichen. Diese Flags können separat 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 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 es sucht diese 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 sollte. Wenn das m-Flag verwendet wird, passen ^ und $ am Anfang oder Ende jeder Zeile innerhalb der Eingabezeichenkette anstatt am Anfang oder Ende der gesamten Zeichenkette.

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

Verwendung des globalen Such-Flags 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 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; das bedeutet, reguläre Ausdrücke, die das Abgleichen mit Unicode-Text unterstützen. Eine wichtige Funktion, die im Unicode-Modus aktiviert ist, sind Unicode-Eigenschaften-Auszugszeichen. Zum Beispiel könnte der folgende reguläre Ausdruck verwendet werden, um gegen ein beliebiges Unicode-"Wort" abzugleichen:

/\p{L}*/u;

Unicode-Regulärausdrücke haben auch ein anderes Ausführungsverhalten. RegExp.prototype.unicode enthält mehr Erklärung dazu.

Im folgenden Beispiel wird vom Benutzer erwartet, dass er eine Telefonnummer eingibt. Wenn der Benutzer auf die Schaltfläche "Überprü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, dass die Telefonnummer ungü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 schließenden Klammer \), in einer nicht-erfassenden Gruppe (?:)
3. gefolgt von einem Bindestrich, Schrägstrich oder Punkt in einer erfassenden Gruppe ()
4. gefolgt von drei Ziffern \d{3}
5. gefolgt von der übereinstimmenden in der (ersten) erfassten Gruppe \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, & Playground.

Regex Visualizer

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

• Zurück
• Weiter