Capturing group: (...)

pattern

Ein Muster, das alles enthalten kann, was Sie in einem Regex-Literal verwenden können, einschließlich einer disjunction.

Eine erfassende Gruppe wirkt wie der Gruppenoperator in JavaScript-Ausdrücken und ermöglicht es Ihnen, ein Teilmuster als einzelnes Atom zu verwenden.

Erfassende Gruppen werden nach der Reihenfolge ihrer öffnenden Klammern nummeriert. Die erste erfassende Gruppe wird mit 1 nummeriert, die zweite mit 2 und so weiter. Benannte erfasste Gruppen sind ebenfalls erfassende Gruppen und werden zusammen mit anderen (unbenannten) erfassenden Gruppen nummeriert. Die Informationen über das Match der erfassenden Gruppe können abgerufen werden durch:

• Den Rückgabewert (der ein Array ist) von RegExp.prototype.exec(), String.prototype.match(), und String.prototype.matchAll()
• Die pN Parameter der replacement Callback-Funktion der Methoden String.prototype.replace() und String.prototype.replaceAll()
• Backreferences innerhalb desselben Musters

Erfassende Gruppen im Regex-Quellcode entsprechen ihren Ergebnissen eins zu eins. Wenn eine erfassende Gruppe nicht gematcht wird (z. B. gehört sie zu einer nicht gematchten Alternative in einer disjunction), ist das entsprechende Ergebnis undefined.

/(ab)|(cd)/.exec("cd"); // ['cd', undefined, 'cd']

Erfassende Gruppen können quantifiziert werden. In diesem Fall sind die Match-Informationen, die dieser Gruppe entsprechen, das letzte Match der Gruppe.

/([ab])+/.exec("abc"); // ['ab', 'b']; because "b" comes after "a", this result overwrites the previous one

Erfassende Gruppen können in Lookahead und Lookbehind Assertions verwendet werden. Da Lookbehind-Assertions ihre Atome rückwärts matchen, ist das finale Match, das dieser Gruppe entspricht, dasjenige, das am linken Ende des Strings erscheint. Die Indizes der Match-Gruppen entsprechen jedoch weiterhin ihren relativen Positionen im Regex-Quellcode.

/c(?=(ab))/.exec("cab"); // ['c', 'ab']
/(?<=(a)(b))c/.exec("abc"); // ['c', 'a', 'b']
/(?<=([ab])+)c/.exec("abc"); // ['c', 'a']; because "a" is seen by the lookbehind after the lookbehind has seen "b"

Erfassende Gruppen können verschachtelt sein, wobei zuerst die äußere Gruppe nummeriert wird und dann die innere Gruppe, da sie nach ihren öffnenden Klammern geordnet sind. Wenn eine verschachtelte Gruppe durch einen Quantor wiederholt wird, werden jedes Mal, wenn die Gruppe matcht, die Ergebnisse der Untergruppen alle überschrieben, manchmal mit undefined.

/((a+)?(b+)?(c))*/.exec("aacbbbcac"); // ['aacbbbcac', 'ac', 'a', undefined, 'c']

Im obigen Beispiel wird die äußere Gruppe dreimal gematcht:

1. Matcht "aac", mit Untergruppen "aa", undefined, und "c".
2. Matcht "bbbc", mit Untergruppen undefined, "bbb", und "c".
3. Matcht "ac", mit Untergruppen "a", undefined, und "c".

Das "bbb" Ergebnis aus dem zweiten Match wird nicht beibehalten, da das dritte Match es mit undefined überschreibt.

Sie können die Start- und Endindizes jeder erfassenden Gruppe im Eingabestring erhalten, indem Sie das d Flag verwenden. Dies erstellt eine zusätzliche indices Eigenschaft auf dem von exec() zurückgegebenen Array.

Sie können optional einer erfassenden Gruppe einen Namen zuweisen, was hilft, Fallstricke in Bezug auf Gruppenpositionen und Indizierung zu vermeiden. Lesen Sie Benannte erfasste Gruppen für weitere Informationen.

Klammern haben andere Zwecke in unterschiedlichen Regex-Syntaxen. Zum Beispiel umfassen sie auch Lookahead- und Lookbehind-Assertions. Da diese Syntaxen alle mit ? beginnen, und ? ein Quantor ist, der normalerweise nicht direkt nach ( auftreten kann, führt dies nicht zu Mehrdeutigkeiten.

Das folgende Beispiel matcht ein Datum im Format YYYY-MM-DD:

function parseDate(input) {
  const parts = /^(\d{4})-(\d{2})-(\d{2})$/.exec(input);
  if (!parts) {
    return null;
  }
  return parts.slice(1).map((p) => parseInt(p, 10));
}

parseDate("2019-01-01"); // [2019, 1, 1]
parseDate("2019-06-19"); // [2019, 6, 19]

Die folgende Funktion matcht die Muster title='xxx' und title="xxx" in einem String. Um sicherzustellen, dass die Anführungszeichen übereinstimmen, verwenden wir einen Backreference, um auf das erste Anführungszeichen zu verweisen. Der Zugriff auf die zweite erfassende Gruppe ([2]) gibt den String zwischen den übereinstimmenden Anführungszeichen zurück:

function parseTitle(metastring) {
  return metastring.match(/title=(["'])(.*?)\1/)[2];
}

parseTitle('title="foo"'); // 'foo'
parseTitle("title='foo' lang='en'"); // 'foo'
parseTitle('title="Named capturing groups\' advantages"'); // "Named capturing groups' advantages"

• Gruppen und Backreferences Leitfaden
• Reguläre Ausdrücke
• Nicht-erfassende Gruppe: (?:...)
• Benannte erfassende Gruppe: (?<name>...)
• Backreference: \1, \2