RegExp

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

• Die Literal-Notation verwendet ein Muster zwischen zwei Schrägstrichen, gefolgt von optionalen Flags nach dem zweiten Schrägstrich.
• 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 Ausdrücke erzeugen 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 durchzuführen. Mehr über den Prozess finden Sie in den dotnet docs.

Die Literal-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) wird einen neuen RegExp unter Verwendung der Quelle des ersten Parameters und der durch den zweiten bereitgestellten Flags erstellen.

Bei der Verwendung der Konstruktorfunktion sind die normalen Escape-Regeln für Zeichenfolgen (Spezialzeichen mit \ voranstellen, wenn sie in einer Zeichenfolge enthalten sind) erforderlich.

Zum Beispiel sind die folgenden Äquivalente:

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

Einige eingebaute Methoden behandeln Regexes speziell. Sie entscheiden, ob x ein Regex ist, durch mehrere Schritte:

1. x muss ein Objekt sein (nicht primitiv).
2. Wenn x[Symbol.match] nicht undefined ist, überprüfen Sie, ob es wahr ist.
3. Andernfalls, wenn x[Symbol.match] undefined ist, überprü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 tatsächliches RegExp-Objekt, dessen Symbol.match-Eigenschaftswert falsch ist, aber nicht undefined (auch wenn alles andere intakt ist, wie exec und [Symbol.replace]()), kann verwendet werden, als ob es kein Regex wäre.
• Ein Nicht-RegExp-Objekt mit einer Symbol.match-Eigenschaft wird behandelt, als wäre es ein Regex.

Diese Entscheidung wurde getroffen, weil [Symbol.match]() die aussagekräftigste Eigenschaft ist, die darauf hinweist, dass etwas zum Abgleichen verwendet werden soll. (exec könnte auch verwendet werden, aber da es sich nicht um eine Symboleigenschaft handelt, würde es zu viele Fehlalarme geben.) 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 globale Flag gesetzt ist, wenn das erste Argument ein Regex ist, bevor es seine [Symbol.matchAll]() oder [Symbol.replace]() Methode aufruft.
• Der RegExp() Konstruktor gibt direkt das pattern-Argument zurück, nur wenn pattern ein Regex ist (unter einigen anderen Bedingungen). Wenn pattern ein Regex ist, würde es auch die source- und flags-Eigenschaften von pattern abfragen, anstatt pattern zu einem String zu zwingen.

Zum Beispiel würde String.prototype.endsWith() alle Eingaben zu Strings zwingen, aber es würde einen Fehler werfen, wenn das Argument ein Regex ist, da es nur dazu gedacht ist, Strings abzugleichen, 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 umgebenden Schrägstrichen, die durch re.toString() hinzugefügt werden, erstellen 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 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, aus der JavaScript seine regulären Ausdrücke modelliert hat.) Siehe auch Veraltete RegExp-Eigenschaften.

RegExp()

Erstellt ein neues RegExp-Objekt.

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

Statische, schreibgeschützte Eigenschaften, die klammernde Teilstringübereinstimmungen enthalten.

RegExp.input ($_) Veraltet

Eine statische Eigenschaft, die den letzten String enthält, gegen den ein regulärer Ausdruck erfolgreich 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 die zuletzt klammernde Teilstringübereinstimmung enthält.

RegExp.leftContext ($`) Veraltet

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

RegExp.rightContext ($') Veraltet

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

RegExp[Symbol.species]

Die Konstruktorfunktion, die zum Erstellen abgeleiteter Objekte verwendet wird.

RegExp.escape()

Escapes alle potenziellen regulären Ausdrucks-Syntaxzeichen in einem String und gibt einen neuen String zurück, der als literal Muster für den RegExp() Konstruktor sicher verwendet werden kann.

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

RegExp.prototype.constructor

Die Konstruktorfunktion, 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 gegen alle möglichen Übereinstimmungen in einem String getestet wird oder nur gegen die erste.

RegExp.prototype.hasIndices

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

RegExp.prototype.ignoreCase

Ob die Groß- und Kleinschreibung beim Versuch, eine Übereinstimmung in einem String zu finden, 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 auf den u-Modus, aktiviert ist oder nicht.

Diese Eigenschaften sind eigene Eigenschaften jeder RegExp-Instanz.

lastIndex

Der Index, an dem die nächste Übereinstimmung starten soll.

RegExp.prototype.compile() Veraltet

(Neu-)kompiliert einen regulären Ausdruck während der Ausführung eines Skripts.

RegExp.prototype.exec()

Führt eine Suche nach einer Übereinstimmung in seinem String-Parameter aus.

RegExp.prototype.test()

Testet nach einer Übereinstimmung in seinem String-Parameter.

RegExp.prototype.toString()

Gibt einen String zurück, der das angegebene Objekt darstellt. Überschreibt die Object.prototype.toString() Methode.

RegExp.prototype[Symbol.match]()

Führt eine Übereinstimmung auf einen gegebenen String aus und gibt das Übereinstimmungsergebnis zurück.

RegExp.prototype[Symbol.matchAll]()

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

RegExp.prototype[Symbol.replace]()

Ersetzt Übereinstimmungen in einem gegebenen String durch einen neuen Teilstring.

RegExp.prototype[Symbol.search]()

Sucht die Übereinstimmung 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 aufgetrennt wird.

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

Im Ersetzungstext verwendet das Skript $1 und $2, um die Ergebnisse der entsprechenden Klammernpaarungen 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".

Das Standardzeilenende variiert je nach Plattform (Unix, Windows, usw.). Die in diesem Beispiel gezeigte Zeilenaufteilung 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 regulären Ausdruck von Bedeutung ist.

Standardmäßig stimmt das Zeichen . nicht mit Zeilenumbrüchen überein. Um es mit Zeilenumbrüchen ü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"]

Das sticky-Flag zeigt an, dass der reguläre Ausdruck beim Zielstring ein Sticky-Matching durchführt, indem versucht wird, bei 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)

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

\w und \W stimmen nur mit ASCII-basierten Zeichen überein; zum Beispiel a bis z, A bis Z, 0 bis 9 und _.

Um Zeichen aus anderen Sprachen wie Kyrillisch oder Hebräisch abzugleichen, verwenden Sie \uHHHH, wobei HHHH der Unicode-Wert des Zeichens in hexadezimaler Schreibweise ist.

Dieses Beispiel zeigt, wie man Unicide-Zeichen eines Wortes 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

Die Unicode-Eigenschaftszeichenklassen Funktion bietet eine einfachere Möglichkeit, bestimmte Unicode-Bereiche anzusprechen, indem Anweisungen wie \p{scx=Cyrl} (um ein beliebiges kyrillisches Zeichen abzugleichen) oder \p{L}/u (um einen Buchstaben aus einer beliebigen Sprache abzugleichen) ermöglicht werden.

Ab Firefox 34 ist im Fall einer erkennenden Gruppe mit Quantoren, die ihre Übung verhindern, der abgeglichene Text für eine Klammerngruppe nun 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 Web-Kompatibilität RegExp.$N 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
• Reguläre Ausdrücke Leitfaden
• Reguläre Ausdrücke
• String.prototype.match()
• String.prototype.replace()
• String.prototype.split()