RegExp

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

• Die literale Notation nimmt ein Muster zwischen zwei Schrägstrichen an, gefolgt von optionalen Flags nach dem zweiten Schrägstrich.
• Die Konstruktorfunktion 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 erstellen das gleiche 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-Dokumentationen.

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 Kompilierung des regulären Ausdrucks zur Laufzeit.

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, indem die Quelle des ersten Parameters und die Flags bereitgestellt durch den zweiten verwendet werden.

Bei Verwendung der Konstruktorfunktion sind die normalen Escape-Regeln für Strings erforderlich (besondere Zeichen mit \ kennzeichnen, wenn sie in einem String enthalten sind).

Zum Beispiel sind die folgenden gleichwertig:

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

Einige eingebaute Methoden würden Regexe speziell behandeln. Sie entscheiden, ob x ein Regex ist, durch mehrere Schritte:

1. x muss ein Objekt sein (kein primitiver Typ).
2. Wenn x[Symbol.match] nicht undefined ist, prüfen, ob es wahrheitsgemäß ist.
3. Andernfalls, wenn x[Symbol.match] undefined ist, prüfen, 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-Prüfung durchlaufen würde, was bedeutet:

• Ein tatsächliches RegExp-Objekt, dessen Symbol.match Eigenschaftswert falschmäßig ist, aber nicht undefined (selbst 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 ob es ein Regex wäre.

Diese Wahl wurde getroffen, weil [Symbol.match]() die am meisten indikative Eigenschaft dafür ist, dass etwas zum Abgleichen verwendet werden soll. (exec könnte auch verwendet werden, aber da es keine Symbol-Eigenschaft ist, gäbe es zu viele falsche Positive.) Die Orte, die Regexe 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 die Methoden [Symbol.matchAll]() oder [Symbol.replace]() aufgerufen werden.
• Der RegExp() Konstruktor gibt direkt das pattern-Argument nur zurück, wenn pattern ein Regex ist (unter einigen anderen Bedingungen). Wenn pattern ein Regex ist, würde er auch die source- und flags-Eigenschaften des pattern abfragen, anstatt pattern in einen String zu erzwingen.

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

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, von der JavaScript seine regulären Ausdrücke abgeleitet hat.) Siehe auch veraltete RegExp-Eigenschaften.

RegExp()

Erstellt ein neues RegExp-Objekt.

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

Statische, nur lesbare Eigenschaften, die Klammer-Teilzeichenfolgenübereinstimmungen enthalten.

RegExp.input ($_) Veraltet

Eine statische Eigenschaft, die die letzte Zeichenfolge enthält, bei der ein regulärer Ausdruck erfolgreich abgeglichen wurde.

RegExp.lastMatch ($&) Veraltet

Eine statische, nur lesbare Eigenschaft, die die zuletzt abgeglichene Teilzeichenfolge enthält.

RegExp.lastParen ($+) Veraltet

Eine statische, nur lesbare Eigenschaft, die das zuletzt in Klammern gesetzte Teilzeichenfolgenübereinstimmung enthält.

RegExp.leftContext ($`) Veraltet

Eine statische, nur lesbare Eigenschaft, die die vor der letzten Übereinstimmung stehende Teilzeichenfolge enthält.

RegExp.rightContext ($') Veraltet

Eine statische, nur lesbare Eigenschaft, die die nach der letzten Übereinstimmung stehende Teilzeichenfolge enthält.

RegExp[Symbol.species]

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

RegExp.escape()

Entweicht alle potenziellen Syntaxzeichen eines Regex in einem String und gibt einen neuen String zurück, der sicher als literales Muster für den RegExp()-Konstruktor 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 abgleicht oder nicht.

RegExp.prototype.flags

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

RegExp.prototype.global

Ob der reguläre Ausdruck auf alle möglichen Übereinstimmungen in einer Zeichenfolge testet oder nur auf die erste.

RegExp.prototype.hasIndices

Ob das Ergebnis des regulären Ausdrucks die Start- und Endindizes der erfassten Teilzeichenfolgen anzeigt.

RegExp.prototype.ignoreCase

Ob beim Versuch, eine Übereinstimmung in einem String zu finden, die Groß-/Kleinschreibung ignoriert wird.

RegExp.prototype.multiline

Ob in Zeichenfolgen über mehrere Zeilen hinweg gesucht wird oder nicht.

RegExp.prototype.source

Der Text des Musters.

RegExp.prototype.sticky

Ob der Suchvorgang unmittelbarer Natur 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 oder nicht.

Diese Eigenschaften sind eigene Eigenschaften jeder RegExp-Instanz.

lastIndex

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

RegExp.prototype.compile() Veraltet

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

RegExp.prototype.exec()

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

RegExp.prototype.test()

Testet auf eine Übereinstimmung in seinem String-Parameter.

RegExp.prototype.toString()

Gibt eine Zeichenfolge zurück, die das spezifizierte Objekt darstellt. Überschreibt die Methode Object.prototype.toString().

RegExp.prototype[Symbol.match]()

Führt einen Abgleich mit der gegebenen Zeichenfolge durch und gibt das Übereinstimmungsergebnis zurück.

RegExp.prototype[Symbol.matchAll]()

Gibt alle Übereinstimmungen des regulären Ausdrucks in einer Zeichenfolge zurück.

RegExp.prototype[Symbol.replace]()

Ersetzt Übereinstimmungen in der gegebenen Zeichenfolge durch eine neue Teilzeichenfolge.

RegExp.prototype[Symbol.search]()

Durchsucht die Übereinstimmung in einer gegebenen Zeichenfolge und gibt den Index des Musters in der Zeichenfolge zurück.

RegExp.prototype[Symbol.split]()

Teilt die gegebene Zeichenfolge in ein Array, indem es die Zeichenfolge in Teilzeichenfolgen aufteilt.

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

In dem Ersetzungstext verwendet das Skript $1 und $2, um die Ergebnisse der entsprechenden übereinstimmenden Klammern im regulären 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.

Das Standard-Zeilenende variiert je nach Plattform (Unix, Windows, etc.). Die in diesem Beispiel bereitgestellte Zeilenaufteilung 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.

Die sticky-Flagge zeigt an, dass der reguläre Ausdruck eine sticky-Suche in der Zielzeichenfolge durchführt, indem versucht wird, ab dem RegExp.prototype.lastIndex zu suchen.

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 der sticky-Flagge y muss die nächste Übereinstimmung an der lastIndex-Position erfolgen, während sie mit der global-Flagge g an der lastIndex-Position oder später erfolgen 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 der globalen Flagge g würden alle 6 Ziffern abgeglichen, nicht nur 3.

\w und \W stimmen nur mit ASCII-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 Hexadezimalform ist.

Dieses Beispiel zeigt, wie man Unicode-Zeichen aus einem Wort herausfiltern 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 Funktion Unicode-Eigenschaft-Escapes bietet eine einfachere Möglichkeit, bestimmte Unicode-Bereiche zu zielen, indem sie Aussagen wie \p{scx=Cyrl} (um einen beliebigen kyrillischen Buchstaben zu finden) oder \p{L}/u (um einen Buchstaben aus einer beliebigen Sprache zu finden) ermöglicht.

Beginnend mit Firefox 34 ist im Fall einer Gruppenerfassung mit Quantoren, die ihre Ausführung verhindern, der abgeglichene Text für eine Gruppenerfassung 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 Webkompatibilität RegExp.$N weiterhin einen leeren String anstelle von undefined zurückgibt (Fehler 1053944).

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