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}?

Paramètres

atom

Un seul atome.

count

Un entier positif ou nul. Le nombre de fois que l'atome doit être répété.

min

Un entier positif ou nul. Le nombre minimum de fois que l'atome peut être répété.

max Facultatif

Un entier positif ou nul. Le nombre maximum de fois que l'atome peut être répété. S'il est omis, l'atome peut être répété autant de fois que nécessaire.

Description

Un quantificateur est placé après un atome pour le répéter un certain nombre de fois. Il ne peut pas apparaître seul. Chaque quantificateur peut définir un nombre minimum et maximum de fois qu'un motif doit être répété.

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

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 apparaître littéralement sans échappement. La possibilité d'utiliser { et } littéralement sans les échapper est une syntaxe obsolète 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 supérieur 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 répétée ne doit pas nécessairement être la même chaîne de caractères.

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

Par défaut, 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 ? après 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 répétitions.

/a*/.exec("aaa"); // ['aaa']; toute l'entrée est consommée
/a*?/.exec("aaa"); // ['']; il est possible de ne consommer aucun caractère tout en réussissant la correspondance
/^a*?$/.exec("aaa"); // ['aaa']; il est impossible de consommer moins de caractères tout en réussissant la correspondance

Cependant, dès que l'expression rationnelle correspond à la chaîne de caractères à un indice, elle n'essaie pas les indices suivants, même si cela peut consommer moins de caractères.

/a*?$/.exec("aaa"); // ['aaa']; la correspondance réussit déjà au premier caractère, donc l'expression rationnelle ne tente jamais de commencer la correspondance au deuxième caractère

Les quantificateurs gourmands peuvent essayer moins de répétitions 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 manière avide à "abb", mais [abc]c ne peut pas correspondre au reste du motif ("c"), donc le quantificateur est réduit pour ne correspondre qu'à "ab".

Les quantificateurs gourmands évitent de faire correspondre une infinité de chaînes de caractères vides. Si le nombre minimum de correspondances est atteint et que l'atome ne consomme plus de caractères à 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 anticipées peuvent être quantifiées. Il s'agit d'une syntaxe obsolète pour la compatibilité du Web, et vous ne devez pas vous y fier.

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

Exemples

Supprimer les balises HTML

L'exemple suivant supprime les balises HTML encadrées par des chevrons. Notez l'utilisation de ? pour éviter de consommer trop de caractères à la fois.

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

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

Vous pouvez obtenir le même résultat avec une correspondance gourmande, sans permettre au motif répété de correspondre à >.

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

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

Repérer les paragraphes Markdown

En Markdown, les paragraphes sont séparés par une ou plusieurs lignes vides. L'exemple suivant compte tous les paragraphes d'une chaîne de caractères 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 même paragraphe

Un autre paragraphe
`); // 3

Spécifications

Compatibilité des navigateurs

Voir aussi

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