Groupe capturant : (...)

Syntaxe

(pattern)

Paramètres

pattern

Un motif consistant en tout ce que vous pouvez utiliser dans un littéral regex, y compris une disjonction.

Description

Un groupe capturant agit comme l'opérateur de regroupement dans les expressions JavaScript, vous permettant d'utiliser un sous-modèle comme un seul atome.

Les groupes capturant sont numérotés dans l'ordre de leurs parenthèses ouvrantes. Le premier groupe capturant porte le numéro 1, le deuxième 2, et ainsi de suite. Les groupes capturant nommés sont également des groupes capturant et sont numérotés avec les autres groupes capturant (non nommés). Vous pouvez accéder aux informations sur la correspondance du groupe capturant :

• La valeur de retour (qui est un tableau) de RegExp.prototype.exec(), String.prototype.match() et String.prototype.matchAll()
• Les paramètres pN de la fonction de rappel de remplacement des méthodes String.prototype.replace() et String.prototype.replaceAll()
• Les rétro-références dans le même motif

Les groupes capturant dans le code source de l'expression rationnelle correspondent à leurs résultats un par un. Si un groupe capturant n'est pas reconnu (par exemple, s'il appartient à une alternative non reconnue dans une disjonction), le résultat correspondant est undefined.

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

Vous pouvez quantifier les groupes de capture. Dans ce cas, les informations de correspondance associées à ce groupe correspondent à sa dernière correspondance.

/([ab])+/.exec("abc"); // ['ab', 'b']; car "b" vient après "a", ce résultat remplace le précédent

Les groupes capturant peuvent être utilisés dans les assertions anticipées et de précédence. Comme les assertions de précédence reconnaissent leurs atomes à l'envers, la correspondance finale associée à ce groupe est celle qui apparaît à l'extrémité gauche de la chaîne de caractères. Toutefois, les indices des groupes correspondants conservent leurs positions relatives dans le code source de l'expression rationnelle.

/c(?=(ab))/.exec("cab"); // ['c', 'ab']
/(?<=(a)(b))c/.exec("abc"); // ['c', 'a', 'b']
/(?<=([ab])+)c/.exec("abc"); // ['c', 'a']; car l'assertion rétrospective reconnaît "a" après avoir reconnu "b"

Vous pouvez imbriquer les groupes de capture. Dans ce cas, le groupe externe reçoit d'abord son numéro, puis le groupe interne, car ils sont ordonnés selon leurs parenthèses ouvrantes. Si un quantificateur répète un groupe imbriqué, chaque correspondance du groupe remplace les résultats des sous-groupes, parfois par undefined.

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

Dans l'exemple ci-dessus, le groupe externe correspond trois fois :

1. Correspond à "aac", avec les sous-groupes "aa", undefined, et "c".
2. Correspond à "bbbc", avec les sous-groupes undefined, "bbb", et "c".
3. Correspond à "ac", avec les sous-groupes "a", undefined, et "c".

Le résultat "bbb" de la deuxième correspondance n'est pas conservé, car la troisième correspondance le remplace par undefined.

Vous pouvez obtenir les indices de début et de fin de chaque groupe capturant dans la chaîne de caractères d'entrée en utilisant l'indicateur d. Cela ajoute une propriété indices au tableau retourné par exec().

Vous pouvez éventuellement définir un nom pour un groupe capturant, ce qui aide à éviter les pièges liés aux positions des groupes et à l'indexation. Voir les groupes capturant nommés pour plus d'informations.

Les parenthèses ont d'autres usages dans différentes syntaxes d'expressions rationnelles. Par exemple, elles encadrent également les assertions anticipées et les assertions de précédence. Comme ces syntaxes commencent toutes par ?, et que ? est un quantificateur qui ne peut normalement pas apparaître directement après (, cela ne crée pas d'ambiguïté.

Exemples

Correspondre à une date

L'exemple suivant correspond à une date au format YYYY-MM-DD :

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

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

Associer des guillemets

La fonction suivante correspond aux motifs title='xxx' et title="xxx" dans une chaîne de caractères. Pour garantir que les guillemets correspondent, nous utilisons une rétro-référence pour faire référence au premier guillemet. L'accès au deuxième groupe capturant ([2]) retourne la chaîne de caractères entre les guillemets correspondants :

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

analyserTitre('title="toto"'); // 'toto'
analyserTitre("title='toto' lang='en'"); // 'toto'
analyserTitre('title="Avantages des groupes capturant nommés"'); // "Avantages des groupes capturant nommés"

Spécifications

Compatibilité des navigateurs

Voir aussi

• Le guide des groupes et rétro-références
• Expressions rationnelles
• Groupe non capturant : (?:...)
• Groupe capturant nommé : (?<name>...)
• Rétro-référence : \1, \2