Quantificateur : *, +, ?, {n}, {n,}, {n,m}

Syntaxe

// Gourmand
atom?
atom*
atom+
atom{count}
atom{min,}
atom{min,max}

// Non-gourmand
atom??
atom*?
atom+?
atom{count}?
atom{min,}?
atom{min,max}?

Paramtres

atom

Un seul atome.

count

Un entier positif ou nul. Le nombre de fois que l'atome doit tre rpt.

min

Un entier positif ou nul. Le nombre minimum de fois que l'atome peut tre rpt.

max Facultatif

Un entier positif ou nul. Le nombre maximum de fois que l'atome peut tre rpt. S'il est omis, l'atome peut tre rpt autant de fois que ncessaire.

Description

Un quantificateur est plac aprs un atome pour le rpter un certain nombre de fois. Il ne peut pas apparatre seul. Chaque quantificateur peut dfinir un nombre minimum et maximum de fois qu'un motif doit tre rpt.

Pour les syntaxes {count}, {min,} et {min,max}, il ne peut pas y avoir d'espaces autour des nombres sinon, cela devient un motif littral.

const re = /a{1, 3}/;
re.test("aa"); // false
re.test("a{1, 3}"); // true

Ce comportement est corrig en mode sensible l'Unicode, o les accolades ne peuvent pas apparatre littralement sans chappement. La possibilit d'utiliser { et } littralement sans les chapper est une syntaxe obsolte pour la compatibilit du Web, et vous ne devez pas vous y fier.

/a{1, 3}/u; // SyntaxError: Invalid regular expression: Incomplete quantifier

Une erreur de syntaxe se produit si le minimum est suprieur au maximum.

/a{3,2}/; // SyntaxError: Invalid regular expression: numbers out of order in {} quantifier

Les quantificateurs peuvent faire correspondre plusieurs fois les groupes capturant. Consultez la page sur les groupes de capture pour en savoir plus sur leur comportement dans ce cas.

Chaque correspondance rpte ne doit pas ncessairement tre la mme chane de caractres.

/[ab]*/.exec("aba"); // ['aba']

Par dfaut, les quantificateurs sont gourmands, c'est--dire qu'ils tentent de correspondre autant de fois que possible jusqu' atteindre le maximum ou jusqu' ce qu'aucune autre correspondance ne soit possible. Vous pouvez rendre un quantificateur non gourmand en ajoutant ? aprs celui-ci. Dans ce cas, le quantificateur tente de correspondre le moins de fois possible et ne correspond davantage que s'il est impossible de faire correspondre le reste du motif avec ce nombre de rptitions.

/a*/.exec("aaa"); // ['aaa']; toute l'entre est consomme
/a*?/.exec("aaa"); // ['']; il est possible de ne consommer aucun caractre tout en russissant la correspondance
/^a*?$/.exec("aaa"); // ['aaa']; il est impossible de consommer moins de caractres tout en russissant la correspondance

Cependant, ds que l'expression rationnelle correspond la chane de caractres un indice, elle n'essaie pas les indices suivants, mme si cela peut consommer moins de caractres.

/a*?$/.exec("aaa"); // ['aaa']; la correspondance russit dj au premier caractre, donc l'expression rationnelle ne tente jamais de commencer la correspondance au deuxime caractre

Les quantificateurs gourmands peuvent essayer moins de rptitions s'il est autrement impossible de faire correspondre le reste du motif.

/[ab]+[abc]c/.exec("abbc"); // ['abbc']

Dans cet exemple, [ab]+ correspond d'abord de manire avide "abb", mais [abc]c ne peut pas correspondre au reste du motif ("c"), donc le quantificateur est rduit pour ne correspondre qu' "ab".

Les quantificateurs gourmands vitent de faire correspondre une infinit de chanes de caractres vides. Si le nombre minimum de correspondances est atteint et que l'atome ne consomme plus de caractres cette position, le quantificateur cesse de correspondre. C'est pourquoi /(a*)*/.exec("b") ne provoque pas de boucle infinie.

Les quantificateurs gourmands tentent de correspondre autant de fois que possible ; ils ne maximisent pas la longueur de la correspondance. Par exemple, /(aa|aabaac|ba)*/.exec("aabaac") correspond "aa" puis "ba" au lieu de "aabaac".

Les quantificateurs s'appliquent un seul atome. Si vous souhaitez quantifier un motif plus long ou une disjonction, vous devez le grouper. Les quantificateurs ne peuvent pas s'appliquer aux assertions.

/^*/; // SyntaxError: Invalid regular expression: nothing to repeat

En mode sensible l'Unicode, les assertions anticipes peuvent tre quantifies. Il s'agit d'une syntaxe obsolte pour la compatibilit du Web, et vous ne devez pas vous y fier.

/(?=a)?b/.test("b"); // true ; l'assertion anticipe correspond 0 fois

Exemples

Supprimer les balises HTML

L'exemple suivant supprime les balises HTML encadres par des chevrons. Notez l'utilisation de ? pour viter de consommer trop de caractres la fois.

function retirerBalises(str) {
  return str.replace(/<.+?>/g, "");
}

retirerBalises("<p><em>lorem</em> <strong>ipsum</strong></p>"); // 'lorem ipsum'

Vous pouvez obtenir le mme rsultat avec une correspondance gourmande, sans permettre au motif rpt de correspondre >.

function retirerBalises(str) {
  return str.replace(/<[^>]+>/g, "");
}

retirerBalises("<p><em>lorem</em> <strong>ipsum</strong></p>"); // 'lorem ipsum'

Reprer les paragraphes Markdown

En Markdown, les paragraphes sont spars par une ou plusieurs lignes vides. L'exemple suivant compte tous les paragraphes d'une chane de caractres en faisant correspondre au moins deux sauts de ligne.

function compterParagraphes(str) {
  return str.match(/(?:\r?\n){2,}/g).length + 1;
}

compterParagraphes(`
Paragraphe 1

Paragraphe 2
Contient quelques sauts de ligne, mais reste le mme paragraphe

Un autre paragraphe
`); // 3

Spcifications

Compatibilit des navigateurs

Voir aussi

• Le guide des quantificateurs
• Expressions rationnelles
• Disjonction : |
• Classe de caractres : [...], [^...]