Dieser Inhalt wurde automatisch aus dem Englischen übersetzt, und kann Fehler enthalten. Erfahre mehr über dieses Experiment.

View in English Always switch to English

Gruppen und Rückverweise

Gruppen fassen mehrere Muster als Ganzes zusammen, und erfasste Gruppen liefern zusätzliche Teilübereinstimmungsinformationen, wenn ein regulärer Ausdruck verwendet wird, um mit einem String übereinzustimmen. Rückverweise beziehen sich auf eine zuvor erfasste Gruppe im selben regulären Ausdruck.

Probieren Sie es aus

// Groups
const imageDescription = "This image has a resolution of 1440×900 pixels.";
const regexpSize = /(\d+)×(\d+)/;
const match = imageDescription.match(regexpSize);
console.log(`Width: ${match[1]} / Height: ${match[2]}.`);
// Expected output: "Width: 1440 / Height: 900."

// Backreferences
const findDuplicates = "foo foo bar";
const regex = /\b(\w+)\s+\1\b/g;
console.log(findDuplicates.match(regex));
// Expected output: Array ["foo foo"]

Typen

Zeichen Bedeutung
(x)

Erfassungsgruppe: Passt auf x und merkt sich die Übereinstimmung. Zum Beispiel passt /(foo)/ und merkt sich "foo" in "foo bar".

Ein regulärer Ausdruck kann mehrere Erfassungsgruppen haben. In den Ergebnissen sind Übereinstimmungen mit Erfassungsgruppen typischerweise in einem Array, dessen Mitglieder in derselben Reihenfolge wie die linken Klammern in der Erfassungsgruppe sind. Das ist normalerweise nur die Reihenfolge der Erfassungsgruppen selbst. Dies wird wichtig, wenn Erfassungsgruppen geschachtelt sind. Auf Übereinstimmungen wird mithilfe des Index der Elemente des Ergebnisses ([1], …, [n]) oder über die vordefinierten Eigenschaften des RegExp-Objekts ($1, …, $9) zugegriffen.

Erfassungsgruppen haben eine Leistungsminderung. Falls Sie den übereinstimmenden Teilstring nicht zurückrufen müssen, bevorzugen Sie Klammern ohne Erfassung (siehe unten).

String.prototype.match() gibt keine Gruppen zurück, wenn das /.../g-Flag gesetzt ist. Sie können jedoch weiterhin String.prototype.matchAll() verwenden, um alle Übereinstimmungen zu erhalten.

(?<Name>x)

Benannte Erfassungsgruppe: Passt auf "x" und speichert es in der Gruppen-Eigenschaft der zurückgegebenen Übereinstimmungen unter dem angegebenen Namen <Name>. Die Klammern (< und >) sind für den Gruppennamen erforderlich.

Zum Beispiel, um die Vorwahl der Vereinigten Staaten aus einer Telefonnummer zu extrahieren, könnten wir /\((?<area>\d\d\d)\)/ verwenden. Die resultierende Nummer würde unter matches.groups.area erscheinen.

(?:x)

Ohne Erfassung Gruppe: Passt auf "x", merkt sich aber die Übereinstimmung nicht. Der übereinstimmende Teilstring kann nicht aus den Elementen des resultierenden Arrays ([1], …, [n]) oder über die vordefinierten Eigenschaften des RegExp-Objekts ($1, …, $9) aufgerufen werden.

(?flags:x), (?flags-flags:x)

Modifier: Aktiviert oder deaktiviert die angegebenen Flags nur für das eingeschlossene Muster. Nur die Flags i, m und s können in einem Modifier verwendet werden.

\n

Rückverweis: Dabei ist "n" eine positive Ganzzahl. Passt den gleichen Teilstring, der von der n-ten Erfassungsgruppe im regulären Ausdruck (zählend ab linken Klammern) übereinstimmt. Zum Beispiel, /apple(,)\sorange\1/ passt "apple, orange," in "apple, orange, cherry, peach".

\k<Name>

Benannter Rückverweis: Ein Rückverweis auf den letzten Teilstring, der die Benannte Erfassungsgruppe übereinstimmt, die durch <Name> angegeben ist.

Zum Beispiel, /(?<title>\w+), yes \k<title>/ passt auf "Sir, yes Sir" in "Do you copy? Sir, yes Sir!".

Hinweis: \k wird hier buchstäblich verwendet, um den Beginn eines Rückverweises auf eine Benannte Erfassungsgruppe anzuzeigen.

Beispiele

Verwendung von Gruppen

In diesem Beispiel passen wir zwei Wörter in einem strukturierten Format an, indem wir Erfassungsgruppen verwenden, um sie zu speichern. \w+ entspricht einem oder mehreren Wortzeichen, und die Klammern () erstellen eine Erfassungsgruppe. Das g-Flag wird verwendet, um alle Vorkommen abzugleichen.

js
const personList = `First_Name: John, Last_Name: Doe
First_Name: Jane, Last_Name: Smith`;

const regexpNames = /First_Name: (\w+), Last_Name: (\w+)/g;
for (const match of personList.matchAll(regexpNames)) {
  console.log(`Hello ${match[1]} ${match[2]}`);
}

Siehe weitere Beispiele im Erfassungsgruppe-Referenz.

Verwendung benannter Gruppen

Dieses Beispiel ist dasselbe wie das obige, aber wir verwenden benannte Erfassungsgruppen, um die übereinstimmenden Wörter zu speichern. Auf diese Weise können wir auf die übereinstimmenden Wörter anhand ihrer Bedeutungen zugreifen.

js
const personList = `First_Name: John, Last_Name: Doe
First_Name: Jane, Last_Name: Smith`;

const regexpNames =
  /First_Name: (?<firstName>\w+), Last_Name: (?<lastName>\w+)/g;
for (const match of personList.matchAll(regexpNames)) {
  console.log(`Hello ${match.groups.firstName} ${match.groups.lastName}`);
}

Siehe weitere Beispiele im benannte Erfassungsgruppe-Referenz.

Verwendung von Gruppen und Rückverweisen

In diesem Beispiel passen wir zuerst ein einzelnes oder doppeltes Anführungszeichen mit ['"], speichern es, passen eine beliebige Anzahl von Zeichen mit .*? (*? ist ein nicht-gieriger Quantor), bis wir das gespeicherte Anführungszeichen erneut mit \1 anpassen. Das \1 ist ein Rückverweis auf die erste Erfassungsgruppe, die denselben Typ von Anführungszeichen übereinstimmt. Das Ergebnis sind also zwei Strings: "'" und '"'.

js
const quote = `Single quote "'" and double quote '"'`;
const regexpQuotes = /(['"]).*?\1/g;
for (const match of quote.matchAll(regexpQuotes)) {
  console.log(match[0]);
}

Siehe weitere Beispiele im Rückverweis-Referenz.

Verwendung von Gruppen und Übereinstimmungsindizes

Indem Sie das d-Flag bereitstellen, werden die Indizes jeder Erfassungsgruppe zurückgegeben. Dies ist besonders nützlich, wenn Sie jede übereinstimmende Gruppe mit dem ursprünglichen Text in Verbindung bringen — zum Beispiel, um Compiler-Diagnosen bereitzustellen.

js
const code = `function add(x, y) {
  return x + y;
}`;
const functionRegexp =
  /(function\s+)(?<name>[$_\p{ID_Start}][$\p{ID_Continue}]*)/du;
const match = functionRegexp.exec(code);
const lines = code.split("\n");
lines.splice(
  1,
  0,
  " ".repeat(match.indices[1][1] - match.indices[1][0]) +
    "^".repeat(match.indices.groups.name[1] - match.indices.groups.name[0]),
);
console.log(lines.join("\n"));
// function add(x, y) {
//          ^^^
//   return x + y;
// }

Siehe auch