RegExp

Beschreibung

Literale Notation und Konstruktor

Es gibt zwei Mglichkeiten, ein RegExp-Objekt zu erstellen: eine literale Notation und einen Konstruktor.

• Die literale Notation nimmt ein Muster zwischen zwei Schrgstrichen, gefolgt von optionalen Flags nach dem zweiten Schrgstrich.
• Die Konstruktor-Funktion nimmt entweder einen String oder ein RegExp-Objekt als ersten Parameter und einen String von optionalen Flags als zweiten Parameter.

Die folgenden drei Ausdrcke erzeugen dasselbe regulre Ausdrucksobjekt:

const re = /ab+c/i; // literal notation
// OR
const re = new RegExp("ab+c", "i"); // constructor with string pattern as first argument
// OR
const re = new RegExp(/ab+c/, "i"); // constructor with regular expression literal as first argument

Bevor regulre Ausdrcke verwendet werden knnen, mssen sie kompiliert werden. Dieser Prozess ermglicht es ihnen, bereinstimmungen effizienter zu finden. Mehr ber den Prozess finden Sie in den dotnet-Dokumenten.

Die literale Notation fhrt zur Kompilierung des regulren Ausdrucks, wenn der Ausdruck ausgewertet wird. Andererseits fhrt der Konstruktor des RegExp-Objekts, new RegExp('ab+c'), zur Laufzeit zur Kompilierung des regulren Ausdrucks.

Verwenden Sie einen String als erstes Argument des RegExp() Konstruktors, wenn Sie den regulren Ausdruck aus dynamischen Eingaben erstellen wollen.

Flags im Konstruktor

Der Ausdruck new RegExp(/ab+c/, flags) erstellt ein neues RegExp, indem die Quelle des ersten Parameters und die vom zweiten bereitgestellten Flags verwendet werden.

Beim Verwenden der Konstruktorfunktion sind die normalen String-Escape-Regeln erforderlich (besondere Zeichen mssen in einem String mit \ eingefgt werden).

Zum Beispiel sind die folgenden gleichwertig:

const re = /\w+/;
// OR
const re = new RegExp("\\w+");

Spezielle Behandlung von Regexen

Einige eingebaute Methoden behandeln Regexe speziell. Sie bestimmen in mehreren Schritten, ob x ein Regex ist:

1. x muss ein Objekt sein (kein primitiver Typ).
2. Wenn x[Symbol.match] nicht undefined ist, berprfen Sie, ob es truthy ist.
3. Andernfalls, wenn x[Symbol.match] undefined ist, berprfen Sie, ob x mit dem RegExp-Konstruktor erstellt wurde. (Dieser Schritt sollte selten auftreten, da, wenn x ein RegExp-Objekt ist, das nicht verndert wurde, es eine Symbol.match-Eigenschaft haben sollte.)

Beachten Sie, dass in den meisten Fllen die Symbol.match-berprfung durchgefhrt wird, was bedeutet:

• Ein tatschliches RegExp-Objekt, dessen Symbol.match-Eigenschaftswert falsy aber nicht undefined ist (selbst wenn alles andere intakt bleibt, wie exec und [Symbol.replace]()), kann verwendet werden, als ob es kein Regex wre.
• Ein Nicht-RegExp-Objekt mit einer Symbol.match-Eigenschaft wird behandelt, als wre es ein Regex.

Diese Wahl wurde getroffen, weil [Symbol.match]() die am besten indizierende Eigenschaft ist, dass etwas zum Abgleichen verwendet werden soll. (exec knnte auch verwendet werden, aber da es keine Symbol-Eigenschaft ist, wrde es zu viele Fehlalarme geben.) Zu den Stellen, die Regexe speziell behandeln, gehren:

• String.prototype.endsWith(), startsWith() und includes() werfen einen TypeError, wenn das erste Argument ein Regex ist.
• String.prototype.matchAll() und replaceAll() berprfen, ob das globale Flag gesetzt ist, wenn das erste Argument ein Regex ist, bevor seine [Symbol.matchAll]() oder [Symbol.replace]() Methode aufgerufen wird.
• Der RegExp() Konstruktor gibt direkt das pattern-Argument nur dann zurck, wenn pattern ein Regex ist (neben einigen anderen Bedingungen). Wenn pattern ein Regex ist, wrde es auch die source- und flags-Eigenschaften von pattern abfragen, anstatt pattern in einen String zu zwingen.

Zum Beispiel wrde String.prototype.endsWith() alle Eingaben in Strings umwandeln, aber es wrde eine Ausnahme auslsen, wenn das Argument ein Regex ist, da es nur zum Abgleichen von Strings gedacht ist und die Verwendung eines Regex wahrscheinlich ein Entwicklerfehler ist.

"foobar".endsWith({ toString: () => "bar" }); // true
"foobar".endsWith(/bar/); // TypeError: First argument to String.prototype.endsWith must not be a regular expression

Sie knnen die Prfung umgehen, indem Sie [Symbol.match] auf einen falsy Wert setzen, der nicht undefined ist. Dies wrde bedeuten, dass das Regex nicht fr String.prototype.match() verwendet werden kann (da ohne [Symbol.match], match() ein neues RegExp-Objekt mit den zwei durch re.toString() hinzugefgten umschlieenden Schrgstrichen konstruieren wrde), aber es kann fr praktisch alles andere verwendet werden.

const re = /bar/g;
re[Symbol.match] = false;
"/bar/g".endsWith(re); // true
re.exec("bar"); // [ 'bar', index: 0, input: 'bar', groups: undefined ]
"bar & bar".replace(re, "foo"); // 'foo & foo'

Perl-hnliche Eigenschaften von RegExp

Beachten Sie, dass mehrere der RegExp-Eigenschaften sowohl lange als auch kurze (Perl-hnliche) Namen haben. Beide Namen beziehen sich immer auf denselben Wert. (Perl ist die Programmiersprache, nach der sich JavaScript bei der Modellierung seiner regulren Ausdrcke gerichtet hat.) Siehe auch veraltete RegExp-Eigenschaften.

Konstruktor

RegExp()

Erstellt ein neues RegExp-Objekt.

Statische Eigenschaften

RegExp.$1, , RegExp.$9

Statische, schreibgeschtzte Eigenschaften, die geklammerte Teilstring-bereinstimmungen enthalten.

RegExp.input ($_)

Eine statische Eigenschaft, die den letzten String enthlt, gegen den ein regulrer Ausdruck erfolgreich abgeglichen wurde.

RegExp.lastMatch ($&)

Eine statische, schreibgeschtzte Eigenschaft, die den letzten bereinstimmenden Teilstring enthlt.

RegExp.lastParen ($+)

Eine statische, schreibgeschtzte Eigenschaft, die die letzte geklammerte Teilstring-bereinstimmung enthlt.

RegExp.leftContext ($`)

Eine statische, schreibgeschtzte Eigenschaft, die den Teilstring vor der zuletzt gefundenen bereinstimmung enthlt.

RegExp.rightContext ($')

Eine statische, schreibgeschtzte Eigenschaft, die den Teilstring nach der zuletzt gefundenen bereinstimmung enthlt.

RegExp[Symbol.species]

Die Konstruktorfunktion, die verwendet wird, um abgeleitete Objekte zu erstellen.

Statische Methoden

RegExp.escape()

Entfernt alle potenziellen Regex-Syntaxzeichen aus einem String und gibt einen neuen String zurck, der sicher als literal Muster fr den RegExp() Konstruktor verwendet werden kann.

Instanz-Eigenschaften

Diese Eigenschaften sind auf RegExp.prototype definiert und werden von allen RegExp-Instanzen geteilt.

RegExp.prototype.constructor

Die Konstruktorfunktion, die das Instanz-Objekt erstellt hat. Fr RegExp-Instanzen ist der Anfangswert der RegExp-Konstruktor.

RegExp.prototype.dotAll

Ob . Zeilenumbrche abgleicht oder nicht.

RegExp.prototype.flags

Ein String, der die Flags des RegExp-Objekts enthlt.

RegExp.prototype.global

Ob der regulre Ausdruck gegen alle mglichen bereinstimmungen in einem String getestet werden soll oder nur gegen die erste.

RegExp.prototype.hasIndices

Ob das Ergebnis des regulren Ausdrucks die Anfangs- und Endindices der erfassten Teilstrings freilegt.

RegExp.prototype.ignoreCase

Ob die Gro-/Kleinschreibung beim Versuch eines Abgleichs in einem String ignoriert werden soll.

RegExp.prototype.multiline

Ob in Strings ber mehrere Zeilen hinweg gesucht werden soll oder nicht.

RegExp.prototype.source

Der Text des Musters.

RegExp.prototype.sticky

Ob die Suche "sticky" ist oder nicht.

RegExp.prototype.unicode

Ob Unicode-Funktionen aktiviert sind oder nicht.

RegExp.prototype.unicodeSets

Ob das v-Flag, ein Upgrade des u-Modus, aktiviert ist oder nicht.

Diese Eigenschaften sind eigene Eigenschaften jeder RegExp-Instanz.

lastIndex

Der Index, an dem die nchste bereinstimmung starten soll.

Instanz-Methoden

RegExp.prototype.compile()

Kompiliert den regulren Ausdruck whrend der Ausfhrung eines Skripts neu.

RegExp.prototype.exec()

Fhrt eine Suche nach einer bereinstimmung in seinem Zeichenkettenparameter aus.

RegExp.prototype.test()

Testet eine bereinstimmung in seinem Zeichenkettenparameter.

RegExp.prototype.toString()

Gibt einen String zurck, der das angegebene Objekt darstellt. berschreibt die Object.prototype.toString() Methode.

RegExp.prototype[Symbol.match]()

Fhrt den Abgleich mit der angegebenen Zeichenfolge durch und gibt das bereinstimmungsergebnis zurck.

RegExp.prototype[Symbol.matchAll]()

Gibt alle bereinstimmungen des regulren Ausdrucks gegen eine Zeichenfolge zurck.

RegExp.prototype[Symbol.replace]()

Ersetzt bereinstimmungen in der angegebenen Zeichenfolge durch einen neuen Teilstring.

RegExp.prototype[Symbol.search]()

Sucht die bereinstimmung in der angegebenen Zeichenfolge und gibt den Index zurck, an dem das Muster in der Zeichenfolge gefunden wurde.

RegExp.prototype[Symbol.split]()

Teilt die angegebene Zeichenfolge in ein Array, indem die Zeichenfolge in Teilstrings getrennt wird.

Beispiele

Verwendung eines regulren Ausdrucks zur nderung des Datenformats

Das folgende Skript verwendet die String.prototype.replace() Methode, um einen Namen im Format Vorname Nachname abzugleichen und in das Format Nachname, Vorname auszugeben.

Im Ersetzungstext verwendet das Skript $1 und $2, um die Ergebnisse der entsprechenden Klammerausdrcke im regulren Ausdrucksmuster anzugeben.

const re = /(\w+)\s(\w+)/;
const str = "Maria Cruz";
const newStr = str.replace(re, "$2, $1");
console.log(newStr);

Dies zeigt "Cruz, Maria" an.

Verwendung eines regulren Ausdrucks zum Aufteilen von Zeilen mit unterschiedlichen Zeilenendungen/Enden von Zeilen/Zeilenumbrchen

Das Standard-Zeilenende variiert je nach Plattform (Unix, Windows, etc.). Die Zeilenaufteilung, die in diesem Beispiel bereitgestellt wird, funktioniert auf allen Plattformen.

const text = "Some text\nAnd some more\r\nAnd yet\nThis is the end";
const lines = text.split(/\r?\n/);
console.log(lines); // [ 'Some text', 'And some more', 'And yet', 'This is the end' ]

Beachten Sie, dass die Reihenfolge der Muster im regulren Ausdruck von Bedeutung ist.

Verwendung eines regulren Ausdrucks ber mehrere Zeilen

Standardmig stimmt das Zeichen . nicht mit Zeilenumbrchen berein. Um es mit Zeilenumbrchen bereinstimmen zu lassen, verwenden Sie das s-Flag (dotAll-Modus).

const s = "Please yes\nmake my day!";

s.match(/yes.*day/);
// Returns null

s.match(/yes.*day/s);
// Returns ["yes\nmake my day"]

Verwendung eines regulren Ausdrucks mit dem Sticky-Flag

Das sticky-Flag zeigt an, dass der regulre Ausdruck eine Sticky-bereinstimmung in der Zielzeichenfolge durchfhrt, indem versucht wird, abzuklren ab RegExp.prototype.lastIndex zu beginnen.

const str = "#foo#";
const regex = /foo/y;

regex.lastIndex = 1;
regex.test(str); // true
regex.lastIndex = 5;
regex.test(str); // false (lastIndex is taken into account with sticky flag)
regex.lastIndex; // 0 (reset after match failure)

Der Unterschied zwischen dem Sticky-Flag und dem globalen Flag

Mit dem Sticky-Flag y muss das nchste Match an der lastIndex-Position stattfinden, whrend mit dem globalen Flag g das Match an der lastIndex-Position oder spter stattfinden kann:

const re = /\d/y;
let r;
while ((r = re.exec("123 456"))) {
  console.log(r, "AND re.lastIndex", re.lastIndex);
}

// [ '1', index: 0, input: '123 456', groups: undefined ] AND re.lastIndex 1
// [ '2', index: 1, input: '123 456', groups: undefined ] AND re.lastIndex 2
// [ '3', index: 2, input: '123 456', groups: undefined ] AND re.lastIndex 3
//   and no more match.

Mit dem globalen Flag g wrden alle 6 Ziffern abgeglichen, nicht nur 3.

Regulrer Ausdruck und Unicode-Zeichen

\w und \W stimmen nur mit Zeichen auf ASCII-Basis berein, zum Beispiel von a bis z, A bis Z, 0 bis 9 und _.

Um Zeichen aus anderen Sprachen wie Kyrillisch oder Hebrisch abzugleichen, verwenden Sie \uHHHH, wobei HHHH der Unicode-Wert des Zeichens in Hexadezimaldarstellung ist.

Dieses Beispiel zeigt, wie man Unicode-Zeichen aus einem Wort heraustrennen kann.

const text = " text   ";
const regex = /[\u0400-\u04ff]+/g;

const match = regex.exec(text);
console.log(match[0]); // ''
console.log(regex.lastIndex); // 7

const match2 = regex.exec(text);
console.log(match2[0]); // '' (did not log 'text')
console.log(regex.lastIndex); // 15

// and so on

Die Unicode-Eigenschafts-Eskapaden Funktion bietet eine einfachere Mglichkeit, bestimmte Unicode-Bereiche zu anvisieren, indem Erklrungen wie \p{scx=Cyrl} (um einen beliebigen kyrillischen Buchstaben abzugleichen) oder \p{L}/u (um einen Buchstaben aus jeder Sprache abzugleichen) erlaubt werden.

Extrahierung des Subdomainnamens aus einer URL

const url = "http://xxx.example.com";
console.log(/^https?:\/\/(.+?)\./.exec(url)[1]); // 'xxx'

Erstellung eines regulren Ausdrucks aus dynamischen Eingaben

const breakfasts = ["bacon", "eggs", "oatmeal", "toast", "cereal"];
const order = "Let me get some bacon and eggs, please";

order.match(new RegExp(`\\b(${breakfasts.join("|")})\\b`, "g"));
// Returns ['bacon', 'eggs']

Spezifikationen

Browser-Kompatibilitt

Firefox-spezifische Hinweise

Beginnend mit Firefox 34 ist im Fall einer Fanggruppe mit Quantoren, die deren Ausfhrung verhindern, der abgeglichene Text fr eine Fanggruppe jetzt undefined anstelle eines leeren Strings:

// Firefox 33 or older
"x".replace(/x(.)?/g, (m, group) => {
  console.log(`group: ${JSON.stringify(group)}`);
});
// group: ""

// Firefox 34 or newer
"x".replace(/x(.)?/g, (m, group) => {
  console.log(`group: ${group}`);
});
// group: undefined

Beachten Sie, dass aufgrund der Webkompatibilitt RegExp.$N weiterhin einen leeren String anstelle von undefined zurckgeben wird (Bug 1053944).

Siehe auch

• Polyfill vieler moderner RegExp-Funktionen (dotAll, sticky Flags, benannte Fanggruppen usw.) in core-js
• Leitfaden zu regulren Ausdrcken
• Regulre Ausdrcke
• String.prototype.match()
• String.prototype.replace()
• String.prototype.split()