RegExp

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

• Die literale Notation umfasst ein Muster zwischen zwei Schrägstrichen, gefolgt von optionalen Flags nach dem zweiten Schrägstrich.
• Die Konstruktorfunktion akzeptiert entweder einen String oder ein RegExp-Objekt als erstes Argument und einen String mit optionalen Flags als zweites Argument.

Die folgenden drei Ausdrücke erstellen dasselbe reguläre 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 reguläre Ausdrücke verwendet werden können, müssen sie kompiliert werden. Dieser Prozess ermöglicht es ihnen, Übereinstimmungen effizienter zu finden. Mehr über den Prozess finden Sie in den dotnet docs.

Die literale Notation führt zur Kompilierung des regulären Ausdrucks, wenn der Ausdruck ausgewertet wird. Andererseits führt der Konstruktor des RegExp-Objekts, new RegExp('ab+c'), zur Laufzeitkompilierung des regulären Ausdrucks.

Verwenden Sie einen String als erstes Argument für den RegExp()-Konstruktor, wenn Sie den regulären Ausdruck aus dynamischen Eingaben erstellen möchten.

Der Ausdruck new RegExp(/ab+c/, flags) erstellt ein neues RegExp-Objekt, das die Quelle des ersten Parameters und die durch den zweiten bereitgestellten Flags verwendet.

Bei der Verwendung der Konstruktorfunktion sind die normalen String-Escape-Regeln (wodurch spezielle Zeichen mit \ in einem String eingeschlossen werden) erforderlich.

Zum Beispiel sind die folgenden äquivalent:

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

Einige eingebaute Methoden behandeln Regexes auf besondere Weise. Sie bestimmen, ob x ein Regex ist, durch mehrere Schritte:

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

Beachten Sie, dass in den meisten Fällen die Symbol.match-Überprüfung durchgeführt wird, was bedeutet:

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

Diese Entscheidung wurde getroffen, weil [Symbol.match]() die aussagekräftigste Eigenschaft ist, dass etwas für das Matching verwendet werden soll. (exec könnte auch verwendet werden, aber da es keine Symbol-Eigenschaft ist, gäbe es zu viele Fehlinterpretationen.) Die Orte, die Regexes speziell behandeln, umfassen:

• String.prototype.endsWith(), startsWith() und includes() werfen einen TypeError, wenn das erste Argument ein Regex ist.
• String.prototype.matchAll() und replaceAll() überprüfen, ob das global-Flag gesetzt ist, wenn das erste Argument ein Regex ist, bevor die Methode [Symbol.matchAll]() oder [Symbol.replace]() aufgerufen wird.
• Der RegExp()-Konstruktor gibt direkt das pattern-Argument nur dann zurück, wenn pattern ein Regex ist (neben einigen anderen Bedingungen). Wenn pattern ein Regex ist, werden auch die source- und flags-Eigenschaften von pattern überprüft, anstatt pattern in einen String umzuwandeln.

Zum Beispiel würde String.prototype.endsWith() alle Eingaben in Strings umwandeln, aber es würde einen Fehler werfen, wenn das Argument ein Regex ist, weil es nur dafür ausgelegt ist, Strings zu matchen, 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 können die Überprüfung umgehen, indem Sie [Symbol.match] auf einen falschen Wert setzen, der nicht undefined ist. Das würde bedeuten, dass der Regex nicht für String.prototype.match() verwendet werden kann (da ohne [Symbol.match] match() ein neues RegExp-Objekt mit den beiden umschließenden Schrägstrichen, die von re.toString() hinzugefügt wurden, konstruieren würde), aber er kann praktisch für 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'

Beachten Sie, dass viele der RegExp-Eigenschaften sowohl lange als auch kurze (Perl-ähnliche) Namen haben. Beide Namen beziehen sich immer auf denselben Wert. (Perl ist die Programmiersprache, aus der JavaScript seine regulären Ausdrücke modellierte.) Siehe auch veraltete RegExp-Eigenschaften.

RegExp()

Erstellt ein neues RegExp-Objekt.

RegExp.$1, …, RegExp.$9 Veraltet

Statische schreibgeschützte Eigenschaften, die geklammerte Teilstring-Übereinstimmungen enthalten.

RegExp.input ($_) Veraltet

Eine statische Eigenschaft, die den letzten String enthält, der erfolgreich mit einem regulären Ausdruck abgeglichen wurde.

RegExp.lastMatch ($&) Veraltet

Eine statische schreibgeschützte Eigenschaft, die den zuletzt abgeglichenen Teilstring enthält.

RegExp.lastParen ($+) Veraltet

Eine statische schreibgeschützte Eigenschaft, die den letzten geklammerten Teilstring-Abgleich enthält.

RegExp.leftContext ($`) Veraltet

Eine statische schreibgeschützte Eigenschaft, die den Teilstring vor der letzten Übereinstimmung enthält.

RegExp.rightContext ($') Veraltet

Eine statische schreibgeschützte Eigenschaft, die den Teilstring nach der letzten Übereinstimmung enthält.

RegExp[Symbol.species]

Die Konstrukturfunktion, die zur Erstellung abgeleiteter Objekte verwendet wird.

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

RegExp.prototype.constructor

Die Konstrukturfunktion, die das Instanzobjekt erstellt hat. Für RegExp-Instanzen ist der Anfangswert der RegExp-Konstruktor.

RegExp.prototype.dotAll

Ob . Zeilenumbrüche matched oder nicht.

RegExp.prototype.flags

Ein String, der die Flags des RegExp-Objekts enthält.

RegExp.prototype.global

Ob der reguläre Ausdruck alle möglichen Übereinstimmungen in einem String testet oder nur die erste.

RegExp.prototype.hasIndices

Ob das reguläre Ausdrucksergebnis die Start- und Endindizes der erfassten Teilstrings freigibt.

RegExp.prototype.ignoreCase

Ob bei einem Match-Versuch in einem String die Groß-/Kleinschreibung ignoriert wird.

RegExp.prototype.multiline

Ob in Strings über mehrere Zeilen hinweg gesucht wird 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 zum u-Modus, aktiviert ist.

Diese Eigenschaften sind eigene Eigenschaften jeder RegExp-Instanz.

lastIndex

Der Index, an dem der nächste Abgleich beginnen soll.

RegExp.prototype.compile() Veraltet

Kompiliert (neu) einen regulären Ausdruck während der Ausführung eines Skripts.

RegExp.prototype.exec()

Führt eine Suche nach einem Match in seinem String-Parameter durch.

RegExp.prototype.test()

Testet auf ein Match in seinem String-Parameter.

RegExp.prototype.toString()

Gibt einen String zurück, der das spezifizierte Objekt repräsentiert. Überschreibt die Methode Object.prototype.toString().

RegExp.prototype[Symbol.match]()

Führt einen Abgleich mit einem gegebenen String durch und gibt das Abgleichsergebnis zurück.

RegExp.prototype[Symbol.matchAll]()

Gibt alle Übereinstimmungen des regulären Ausdrucks mit einem String zurück.

RegExp.prototype[Symbol.replace]()

Ersetzt Übereinstimmungen in einem gegebenen String mit einem neuen Teilstring.

RegExp.prototype[Symbol.search]()

Sucht nach dem Abgleich in einem gegebenen String und gibt den Index zurück, an dem das Muster im String gefunden wurde.

RegExp.prototype[Symbol.split]()

Teilt einen gegebenen String in ein Array, indem der String in Teilstrings geteilt wird.

Das folgende Skript verwendet die Methode String.prototype.replace(), um einen Namen im Format Vorname Nachname zu finden und ihn im Format Nachname, Vorname auszugeben.

Im Ersetzungstext verwendet das Skript $1 und $2, um die Ergebnisse der entsprechenden klammer-lokalisierten Parenthesen im regulären Ausdrucksmuster anzuzeigen.

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

Dies zeigt "Cruz, Maria" an.

Das Standardzeilenende variiert je nach Plattform (Unix, Windows usw.). Die Zeilenaufteilung, die in diesem Beispiel bereitgestellt wird, funktioniert auf allen Plattformen.

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

Beachten Sie, dass die Reihenfolge der Muster im regulären Ausdruck wichtig ist.

Das sticky-Flag zeigt an, dass der reguläre Ausdruck ein sticky Matching im Zielstring durchführt, indem versucht wird, bei RegExp.prototype.lastIndex zu matchen.

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)

Mit dem Sticky-Flag y muss das nächste Match an der lastIndex-Position auftreten, während mit dem Global-Flag g das Match an der lastIndex-Position oder später 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 Global-Flag g würden alle 6 Ziffern gematcht, nicht nur 3.

\w und \W vergleichen nur ASCII-basierte Zeichen; zum Beispiel a bis z, A bis Z, 0 bis 9 und _.

Um Zeichen aus anderen Sprachen wie Kyrillisch oder Hebräisch zu vergleichen, verwenden Sie \uhhhh, wobei hhhh der Unicode-Wert des Zeichens im Hexadezimalformat ist.

Dieses Beispiel zeigt, wie man Unicode-Zeichen aus einem Wort trennen 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

Das Unicode-Eigenschafts-Escapes-Feature bietet eine einfachere Möglichkeit, bestimmte Unicode-Bereiche zu haben, indem Anweisungen wie \p{scx=Cyrl} (zum Matchen eines beliebigen kyrillischen Buchstabens) oder \p{L}/u (zum Matchen eines Buchstabens aus jeder Sprache) erlaubt sind.

Beginnend mit Firefox 34 ist im Fall einer Fanggruppe mit Quantifizierern, die ihre Ausübung verhindern, der abgeglichene Text für 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 RegExp.$N aufgrund der Web-Kompatibilität immer noch einen leeren String anstelle von undefined zurückgibt (bug 1053944).

• Polyfill vieler moderner RegExp-Funktionen (dotAll, sticky-Flags, benannte Erfassungsgruppen, usw.) in core-js
• Leitfaden zu regulären Ausdrücken
• Referenz zu regulären Ausdrücken
• String.prototype.match()
• String.prototype.replace()
• String.prototype.split()