quantificateurs dans les expressions régulièresQuantifiers in Regular Expressions

Les quantificateurs spécifient le nombre d’instances d’un caractère, groupe ou classe de caractères devant être présentes dans l’entrée pour qu’une correspondance soit trouvée.Quantifiers specify how many instances of a character, group, or character class must be present in the input for a match to be found. Le tableau suivant répertorie les quantificateurs pris en charge par .NET.The following table lists the quantifiers supported by .NET.

Quantificateur gourmandGreedy quantifier Quantificateur paresseuxLazy quantifier DescriptionDescription
* *? Mettre en correspondance zéro occurrence ou plus.Match zero or more times.
+ +? Mettre en correspondance une ou plusieurs occurrences.Match one or more times.
? ?? Mettre en correspondance zéro ou une occurrence.Match zero or one time.
{n}{ n } {n}?{ n }? Mettre en correspondance exactement n occurrences.Match exactly n times.
{n,}{ n ,} {n,}?{ n ,}? Mettre en correspondance au moins n occurrences.Match at least n times.
{n , m}{ n , m } {n , m}?{ n , m }? Mettre en correspondance entre n et m occurrences.Match from n to m times.

Les quantités n et m sont des constantes entières.The quantities n and m are integer constants. Habituellement, les quantificateurs sont gourmands ; ils obligent le moteur d’expression régulière à faire correspondre autant d’occurrences de modèles particuliers que possible.Ordinarily, quantifiers are greedy; they cause the regular expression engine to match as many occurrences of particular patterns as possible. L’ajout du caractère ? à un quantificateur le rend paresseux ; le moteur d’expression régulière fait alors correspondre aussi peu d’occurrences que possible.Appending the ? character to a quantifier makes it lazy; it causes the regular expression engine to match as few occurrences as possible. Pour une description complète de la différence entre quantificateurs gourmands et paresseux, consultez la section Quantificateurs gourmands et paresseux plus loin dans cette rubrique.For a complete description of the difference between greedy and lazy quantifiers, see the section Greedy and Lazy Quantifiers later in this topic.

Important

L’imbrication des quantificateurs (par exemple, comme le fait le modèle d’expression régulière (a*)*) peut augmenter le nombre de comparaisons que le moteur d’expression régulière doit exécuter, comme une fonction exponentielle du nombre de caractères dans la chaîne d’entrée.Nesting quantifiers (for example, as the regular expression pattern (a*)* does) can increase the number of comparisons that the regular expression engine must perform, as an exponential function of the number of characters in the input string. Pour plus d’informations sur ce comportement et ses solutions de contournement, consultez Rétroaction.For more information about this behavior and its workarounds, see Backtracking.

Quantificateurs d’expression régulièreRegular Expression Quantifiers

Les sections suivantes présentent les quantificateurs pris en charge par les expressions régulières .NET.The following sections list the quantifiers supported by .NET regular expressions.

Notes

Si les caractères *, +, ?, { et } sont rencontrés dans un modèle d’expressions régulières, le moteur d’expression régulière les interprète comme des quantificateurs ou partie de constructions de quantificateur à moins qu’ils ne soient inclus dans une classe de caractères.If the *, +, ?, {, and } characters are encountered in a regular expression pattern, the regular expression engine interprets them as quantifiers or part of quantifier constructs unless they are included in a character class. Pour les interpréter comme des caractères littéraux en dehors d’une classe de caractères, vous devez les placer dans une séquence d’échappement en les faisant précéder d’une barre oblique inverse.To interpret these as literal characters outside a character class, you must escape them by preceding them with a backslash. Par exemple, la chaîne \* dans un modèle d’expression régulière est interprétée comme un caractère astérisque (« * ») littéral.For example, the string \* in a regular expression pattern is interpreted as a literal asterisk ("*") character.

Mettre en correspondance zéro occurrence ou plus : *Match Zero or More Times: *

Le quantificateur * correspond zéro fois, ou plus, à l’élément qui précède.The * quantifier matches the preceding element zero or more times. Il équivaut au quantificateur {0,}.It is equivalent to the {0,} quantifier. * est un quantificateur gourmand dont l’équivalent paresseux est *?.* is a greedy quantifier whose lazy equivalent is *?.

L’exemple suivant illustre cette expression régulière.The following example illustrates this regular expression. Parmi les neuf groupes de chiffres de la chaîne d’entrée, cinq correspondent au modèle et quatre ( 95 , 929 , 9219 et 9919 ) ne le font pas.Of the nine digit groups in the input string, five match the pattern and four (95, 929, 9219, and 9919) do not.

string pattern = @"\b91*9*\b";
string input = "99 95 919 929 9119 9219 999 9919 91119";
foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);

// The example displays the following output:
//       '99' found at position 0.
//       '919' found at position 6.
//       '9119' found at position 14.
//       '999' found at position 24.
//       '91119' found at position 33.
Dim pattern As String = "\b91*9*\b"
Dim input As String = "99 95 919 929 9119 9219 999 9919 91119"
For Each match As Match In Regex.Matches(input, pattern)
    Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next
' The example displays the following output:   
'       '99' found at position 0.
'       '919' found at position 6.
'       '9119' found at position 14.
'       '999' found at position 24.
'       '91119' found at position 33.

Le modèle d’expression régulière est défini comme indiqué dans le tableau suivant.The regular expression pattern is defined as shown in the following table.

ModèlePattern DescriptionDescription
\b Commencer à la limite d'un mot.Start at a word boundary.
91* Mettre en correspondance un « 9 » suivi de zéro, ou plus, caractère « 1 ».Match a "9" followed by zero or more "1" characters.
9* Mettre en correspondance zéro, ou plus, caractère « 9 ».Match zero or more "9" characters.
\b Terminer à une limite de mot.End at a word boundary.

Mettre en correspondance un ou plusieurs chiffres : +Match One or More Times: +

Le quantificateur + correspond une ou plusieurs fois à l’élément qui précède.The + quantifier matches the preceding element one or more times. Il équivaut à {1,}.It is equivalent to {1,}. + est un quantificateur gourmand dont l’équivalent paresseux est +?.+ is a greedy quantifier whose lazy equivalent is +?.

Par exemple, l’expression régulière \ban+\w*?\b tente d’établir une correspondance avec les mots entiers qui commencent par la lettre a suivie d’une ou de plusieurs instances de la lettre n.For example, the regular expression \ban+\w*?\b tries to match entire words that begin with the letter a followed by one or more instances of the letter n. L’exemple suivant illustre cette expression régulière.The following example illustrates this regular expression. L’expression régulière établit une correspondance avec les mots an, annual, announcement et antique, et pas avec les mots autumn et all.The regular expression matches the words an, annual, announcement, and antique, and correctly fails to match autumn and all.

string pattern = @"\ban+\w*?\b";

string input = "Autumn is a great time for an annual announcement to all antique collectors.";
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);

// The example displays the following output:
//       'an' found at position 27.
//       'annual' found at position 30.
//       'announcement' found at position 37.
//       'antique' found at position 57.
Dim pattern As String = "\ban+\w*?\b"

Dim input As String = "Autumn is a great time for an annual announcement to all antique collectors."
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
    Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next
' The example displays the following output:   
'       'an' found at position 27.
'       'annual' found at position 30.
'       'announcement' found at position 37.
'       'antique' found at position 57.      

Le modèle d’expression régulière est défini comme indiqué dans le tableau suivant.The regular expression pattern is defined as shown in the following table.

ModèlePattern DescriptionDescription
\b Commencer à la limite d'un mot.Start at a word boundary.
an+ Mettre en correspondance un « a » suivi d’un ou plusieurs caractères « n ».Match an "a" followed by one or more "n" characters.
\w*? Mettre en correspondance un caractère alphabétique zéro, une ou plusieurs fois, mais le moins de fois possible.Match a word character zero or more times, but as few times as possible.
\b Terminer à une limite de mot.End at a word boundary.

Mettre en correspondance zéro ou une occurrence : ?Match Zero or One Time: ?

Le quantificateur ? correspond zéro ou une fois à l’élément qui précède.The ? quantifier matches the preceding element zero or one time. Il équivaut à {0,1}.It is equivalent to {0,1}. ? est un quantificateur gourmand dont l’équivalent paresseux est ??.? is a greedy quantifier whose lazy equivalent is ??.

Par exemple, l’expression régulière \ban?\b tente d’établir une correspondance avec les mots entiers qui commencent par la lettre a suivie de zéro ou une instance de la lettre n.For example, the regular expression \ban?\b tries to match entire words that begin with the letter a followed by zero or one instances of the letter n. En d’autres termes, elle tente d’établir une correspondance avec les mots a et an.In other words, it tries to match the words a and an. L’exemple suivant illustre cette expression régulière.The following example illustrates this regular expression.

string pattern = @"\ban?\b";
string input = "An amiable animal with a large snount and an animated nose.";
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);

// The example displays the following output:
//        'An' found at position 0.
//        'a' found at position 23.
//        'an' found at position 42.
Dim pattern As String = "\ban?\b"
Dim input As String = "An amiable animal with a large snount and an animated nose."
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
    Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next
' The example displays the following output:   
'       'An' found at position 0.
'       'a' found at position 23.
'       'an' found at position 42.

Le modèle d’expression régulière est défini comme indiqué dans le tableau suivant.The regular expression pattern is defined as shown in the following table.

ModèlePattern DescriptionDescription
\b Commencer à la limite d'un mot.Start at a word boundary.
an? Mettre en correspondance un « a » suivi de zéro ou un caractère « n ».Match an "a" followed by zero or one "n" character.
\b Terminer à une limite de mot.End at a word boundary.

Mettre en correspondance exactement n occurrences : {n}Match Exactly n Times: {n}

Le { n } quantificateur n correspond à l’élément qui précède exactement n fois, où n est un entier.The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n } est un quantificateur gourmand dont l’équivalent paresseux est { n }? .{n} is a greedy quantifier whose lazy equivalent is {n}?.

Par exemple, l’expression régulière \b\d+\,\d{3}\b tente d’établir une correspondance avec une limite de mot suivie d’un ou de plusieurs chiffres décimaux suivis de trois chiffres décimaux suivis d’une limite de mot.For example, the regular expression \b\d+\,\d{3}\b tries to match a word boundary followed by one or more decimal digits followed by three decimal digits followed by a word boundary. L’exemple suivant illustre cette expression régulière.The following example illustrates this regular expression.

string pattern = @"\b\d+\,\d{3}\b";
string input = "Sales totaled 103,524 million in January, " +
                      "106,971 million in February, but only " +
                      "943 million in March.";
foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);

//  The example displays the following output:
//        '103,524' found at position 14.
//        '106,971' found at position 45.
Dim pattern As String = "\b\d+\,\d{3}\b"
Dim input As String = "Sales totaled 103,524 million in January, " + _
                      "106,971 million in February, but only " + _
                      "943 million in March."
For Each match As Match In Regex.Matches(input, pattern)
    Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next
' The example displays the following output:   
'       '103,524' found at position 14.
'       '106,971' found at position 45.

Le modèle d’expression régulière est défini comme indiqué dans le tableau suivant.The regular expression pattern is defined as shown in the following table.

ModèlePattern DescriptionDescription
\b Commencer à la limite d'un mot.Start at a word boundary.
\d+ Mettre en correspondance un ou plusieurs chiffres décimaux.Match one or more decimal digits.
\, Mettre en correspondance une virgule.Match a comma character.
\d{3} Mettre en correspondance trois chiffres décimaux.Match three decimal digits.
\b Terminer à une limite de mot.End at a word boundary.

Mettre en correspondance au moins n occurrences : {n,}Match at Least n Times: {n,}

Le { n ,} quantificateur n correspond à l’élément qui précède au moins n fois, où n est un entier.The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n ,} est un quantificateur gourmand dont l’équivalent paresseux est { n ,}? .{n,} is a greedy quantifier whose lazy equivalent is {n,}?.

Par exemple, l’expression régulière \b\d{2,}\b\D+ tente d’établir une correspondance avec une limite de mot suivie d’au moins deux chiffres suivis d’une limite de mot et d’un caractère non numérique.For example, the regular expression \b\d{2,}\b\D+ tries to match a word boundary followed by at least two digits followed by a word boundary and a non-digit character. L’exemple suivant illustre cette expression régulière.The following example illustrates this regular expression. L’expression régulière ne peut pas établir de correspondance avec l’expression "7 days", car elle ne contient qu’un chiffre. En revanche, une correspondance est établie les expressions "10 weeks and 300 years".The regular expression fails to match the phrase "7 days" because it contains just one decimal digit, but it successfully matches the phrases "10 weeks and 300 years".

string pattern = @"\b\d{2,}\b\D+";
string input = "7 days, 10 weeks, 300 years";
foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);

//  The example displays the following output:
//        '10 weeks, ' found at position 8.
//        '300 years' found at position 18.
Dim pattern As String = "\b\d{2,}\b\D+"
Dim input As String = "7 days, 10 weeks, 300 years"
For Each match As Match In Regex.Matches(input, pattern)
    Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'       '10 weeks, ' found at position 8.
'       '300 years' found at position 18.

Le modèle d’expression régulière est défini comme indiqué dans le tableau suivant.The regular expression pattern is defined as shown in the following table.

ModèlePattern DescriptionDescription
\b Commencer à la limite d'un mot.Start at a word boundary.
\d{2,} Mettre en correspondance au moins deux chiffres décimaux.Match at least two decimal digits.
\b Mettre en correspondance la limite d'un mot.Match a word boundary.
\D+ Mettre en correspondance au moins un chiffre non décimal.Match at least one non-decimal digit.

Mettre en correspondance entre n et m fois : {n, m}Match Between n and m Times: {n,m}

Le { quantificateur n , m } correspond à l’élément qui précède au moins n fois, mais pas plus de m fois, où n et m sont des entiers.The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n , m } est un quantificateur gourmand dont l’équivalent paresseux est { n , m }? .{n,m} is a greedy quantifier whose lazy equivalent is {n,m}?.

Dans l’exemple suivant, l’expression régulière (00\s){2,4} tente d’établir une correspondance entre deux et quatre occurrences de deux zéros suivis d’un espace.In the following example, the regular expression (00\s){2,4} tries to match between two and four occurrences of two zero digits followed by a space. Notez que la partie finale de la chaîne d’entrée inclut ce modèle cinq fois au lieu du maximum de quatre.Note that the final portion of the input string includes this pattern five times rather than the maximum of four. Toutefois, seule la partie initiale de cette sous-chaîne (jusqu’à l’espace et la cinquième paire de zéros) correspond au modèle d’expression régulière.However, only the initial portion of this substring (up to the space and the fifth pair of zeros) matches the regular expression pattern.

string pattern = @"(00\s){2,4}";
string input = "0x00 FF 00 00 18 17 FF 00 00 00 21 00 00 00 00 00";
foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);

//  The example displays the following output:
//        '00 00 ' found at position 8.
//        '00 00 00 ' found at position 23.
//        '00 00 00 00 ' found at position 35.
Dim pattern As String = "(00\s){2,4}"
Dim input As String = "0x00 FF 00 00 18 17 FF 00 00 00 21 00 00 00 00 00"
For Each match As Match In Regex.Matches(input, pattern)
    Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'       '00 00 ' found at position 8.
'       '00 00 00 ' found at position 23.
'       '00 00 00 00 ' found at position 35.

Mettre en correspondance zéro occurrence ou plus (correspondance paresseuse) : *?Match Zero or More Times (Lazy Match): *?

Le quantificateur *? établit zéro, une ou plusieurs correspondances avec l’élément qui précède, mais le moins de fois possible.The *? quantifier matches the preceding element zero or more times, but as few times as possible. Il s’agit de l’équivalent paresseux du quantificateur gourmand *.It is the lazy counterpart of the greedy quantifier *.

Dans l’exemple suivant, l’expression régulière \b\w*?oo\w*?\b correspond à tous les mots qui contiennent la chaîne oo.In the following example, the regular expression \b\w*?oo\w*?\b matches all words that contain the string oo.

 string pattern = @"\b\w*?oo\w*?\b";
 string input = "woof root root rob oof woo woe";
 foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
    Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);

 //  The example displays the following output:
//        'woof' found at position 0.
//        'root' found at position 5.
//        'root' found at position 10.
//        'oof' found at position 19.
//        'woo' found at position 23.
Dim pattern As String = "\b\w*?oo\w*?\b"
Dim input As String = "woof root root rob oof woo woe"
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
    Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'       'woof' found at position 0.
'       'root' found at position 5.
'       'root' found at position 10.
'       'oof' found at position 19.
'       'woo' found at position 23.

Le modèle d’expression régulière est défini comme indiqué dans le tableau suivant.The regular expression pattern is defined as shown in the following table.

ModèlePattern DescriptionDescription
\b Commencer à la limite d'un mot.Start at a word boundary.
\w*? Correspond à zéro, un ou plusieurs caractères alphabétiques, mais le moins de caractères possible.Match zero or more word characters, but as few characters as possible.
oo Mettre en correspondance la chaîne « oo ».Match the string "oo".
\w*? Correspond à zéro, un ou plusieurs caractères alphabétiques, mais le moins de caractères possible.Match zero or more word characters, but as few characters as possible.
\b Terminer sur une limite de mot.End on a word boundary.

Mettre en correspondance une ou plusieurs occurrences (correspondance paresseuse) : +?Match One or More Times (Lazy Match): +?

Le quantificateur +? établit une ou plusieurs correspondances avec l’élément qui précède, mais le moins de fois possible.The +? quantifier matches the preceding element one or more times, but as few times as possible. Il s’agit de l’équivalent paresseux du quantificateur gourmand +.It is the lazy counterpart of the greedy quantifier +.

Par exemple, l’expression régulière \b\w+?\b établit une correspondance avec un ou plusieurs caractères séparés par des limites de mot.For example, the regular expression \b\w+?\b matches one or more characters separated by word boundaries. L’exemple suivant illustre cette expression régulière.The following example illustrates this regular expression.

string pattern = @"\b\w+?\b";
string input = "Aa Bb Cc Dd Ee Ff";
foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);

//  The example displays the following output:
//        'Aa' found at position 0.
//        'Bb' found at position 3.
//        'Cc' found at position 6.
//        'Dd' found at position 9.
//        'Ee' found at position 12.
//        'Ff' found at position 15.
Dim pattern As String = "\b\w+?\b"
Dim input As String = "Aa Bb Cc Dd Ee Ff"
For Each match As Match In Regex.Matches(input, pattern)
    Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'       'Aa' found at position 0.
'       'Bb' found at position 3.
'       'Cc' found at position 6.
'       'Dd' found at position 9.
'       'Ee' found at position 12.
'       'Ff' found at position 15.

Mettre en correspondance zéro ou une occurrence (correspondance paresseuse) : ??Match Zero or One Time (Lazy Match): ??

Le quantificateur ?? établit zéro ou une correspondance avec l’élément qui précède, mais le moins de fois possible.The ?? quantifier matches the preceding element zero or one time, but as few times as possible. Il s’agit de l’équivalent paresseux du quantificateur gourmand ?.It is the lazy counterpart of the greedy quantifier ?.

Par exemple, l’expression régulière ^\s*(System.)??Console.Write(Line)??\(?? tente d’établir une correspondance avec les chaînes « Console.Write » ou « Console.WriteLine ».For example, the regular expression ^\s*(System.)??Console.Write(Line)??\(?? attempts to match the strings "Console.Write" or "Console.WriteLine". La chaîne peut également comprendre « System. »The string can also include "System." avant « Console », et elle peut être suivie par une parenthèse ouvrante.before "Console", and it can be followed by an opening parenthesis. Elle doit se trouver au début d’une ligne, mais peut être précédée d’un espace blanc.The string must be at the beginning of a line, although it can be preceded by white space. L’exemple suivant illustre cette expression régulière.The following example illustrates this regular expression.

string pattern = @"^\s*(System.)??Console.Write(Line)??\(??";
string input = "System.Console.WriteLine(\"Hello!\")\n" +
                      "Console.Write(\"Hello!\")\n" +
                      "Console.WriteLine(\"Hello!\")\n" +
                      "Console.ReadLine()\n" +
                      "   Console.WriteLine";
foreach (Match match in Regex.Matches(input, pattern,
                                      RegexOptions.IgnorePatternWhitespace |
                                      RegexOptions.IgnoreCase |
                                      RegexOptions.Multiline))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);

//  The example displays the following output:
//        'System.Console.Write' found at position 0.
//        'Console.Write' found at position 36.
//        'Console.Write' found at position 61.
//        '   Console.Write' found at position 110.
Dim pattern As String = "^\s*(System.)??Console.Write(Line)??\(??"
Dim input As String = "System.Console.WriteLine(""Hello!"")" + vbCrLf + _
                      "Console.Write(""Hello!"")" + vbCrLf + _
                      "Console.WriteLine(""Hello!"")" + vbCrLf + _
                      "Console.ReadLine()" + vbCrLf + _
                      "   Console.WriteLine"
For Each match As Match In Regex.Matches(input, pattern, _
                                         RegexOptions.IgnorePatternWhitespace Or RegexOptions.IgnoreCase Or RegexOptions.MultiLine)
    Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'       'System.Console.Write' found at position 0.
'       'Console.Write' found at position 36.
'       'Console.Write' found at position 61.
'       '   Console.Write' found at position 110.

Le modèle d’expression régulière est défini comme indiqué dans le tableau suivant.The regular expression pattern is defined as shown in the following table.

ModèlePattern DescriptionDescription
^ Mettre en correspondance le début du flux d’entrée.Match the start of the input stream.
\s* Correspond à zéro, un ou plusieurs espaces blancs.Match zero or more white-space characters.
(System.)?? Mettre en correspondance zéro ou une occurrence de la chaîne « System. ».Match zero or one occurrence of the string "System.".
Console.Write Mettre en correspondance la chaîne « Console.Write ».Match the string "Console.Write".
(Line)?? Mettre en correspondance zéro ou une occurrence de la chaîne « Line ».Match zero or one occurrence of the string "Line".
\(?? Mettre en correspondance zéro occurrence, ou plus, de la parenthèse ouvrante.Match zero or one occurrence of the opening parenthesis.

Mettre en correspondance exactement n occurrences (correspondance paresseuse) : {n}?Match Exactly n Times (Lazy Match): {n}?

Le { n }? quantificateur n correspond exactement à l’élément qui précède n , où n est un entier.The {n}? quantifier matches the preceding element exactly n times, where n is any integer. Il s’agit de l’équivalent paresseux du quantificateur gourmand { n } .It is the lazy counterpart of the greedy quantifier {n}.

Dans l’exemple suivant, l’expression régulière \b(\w{3,}?\.){2}?\w{3,}?\b est utilisée pour identifier une adresse de site web.In the following example, the regular expression \b(\w{3,}?\.){2}?\w{3,}?\b is used to identify a Web site address. Notez qu’elle établit une correspondance avec « www.microsoft.com » et « msdn.microsoft.com », mais pas avec « mywebsite » ou « mycompany.com ».Note that it matches "www.microsoft.com" and "msdn.microsoft.com", but does not match "mywebsite" or "mycompany.com".

string pattern = @"\b(\w{3,}?\.){2}?\w{3,}?\b";
string input = "www.microsoft.com msdn.microsoft.com mywebsite mycompany.com";
foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);

//  The example displays the following output:
//        'www.microsoft.com' found at position 0.
//        'msdn.microsoft.com' found at position 18.
Dim pattern As String = "\b(\w{3,}?\.){2}?\w{3,}?\b"
Dim input As String = "www.microsoft.com msdn.microsoft.com mywebsite mycompany.com"
For Each match As Match In Regex.Matches(input, pattern)
    Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'       'www.microsoft.com' found at position 0.
'       'msdn.microsoft.com' found at position 18.

Le modèle d’expression régulière est défini comme indiqué dans le tableau suivant.The regular expression pattern is defined as shown in the following table.

ModèlePattern DescriptionDescription
\b Commencer à la limite d'un mot.Start at a word boundary.
(\w{3,}?\.) Mettre en correspondance au moins 3 caractères alphabétiques, mais le moins de caractères possible, suivis d’un point ou d’un point final.Match at least 3 word characters, but as few characters as possible, followed by a dot or period character. Il s'agit du premier groupe de capture.This is the first capturing group.
(\w{3,}?\.){2}? Mettre en correspondance le modèle dans le premier groupe deux fois, mais le moins de fois possible.Match the pattern in the first group two times, but as few times as possible.
\b Terminer la correspondance à la limite d'un mot.End the match on a word boundary.

Mettre en correspondance au moins n occurrences (correspondance paresseuse) : {n,}?Match at Least n Times (Lazy Match): {n,}?

Le { n ,}? quantificateur n correspond à l’élément qui précède au moins n fois, où n est un entier, mais le moins de fois possible.The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. Il s’agit de l’équivalent paresseux du quantificateur gourmand { n ,} .It is the lazy counterpart of the greedy quantifier {n,}.

Pour obtenir une illustration, consultez l’exemple du { quantificateur n }? dans la section précédente.See the example for the {n}? quantifier in the previous section for an illustration. L’expression régulière de cet exemple utilise le { n ,} quantificateur n pour faire correspondre une chaîne comportant au moins trois caractères suivis d’un point.The regular expression in that example uses the {n,} quantifier to match a string that has at least three characters followed by a period.

Mettre en correspondance entre n et m fois (correspondance paresseuse) : {n,m}?Match Between n and m Times (Lazy Match): {n,m}?

Le { quantificateur n , m }? correspond à l’élément qui précède entre n et m heures, où n et m sont des entiers, mais le moins de fois possible.The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. Il s’agit de l’équivalent paresseux du quantificateur gourmand { n , m } .It is the lazy counterpart of the greedy quantifier {n,m}.

Dans l’exemple suivant, l’expression régulière \b[A-Z](\w*?\s*?){1,10}[.!?] correspond aux phrases qui contiennent entre un et dix mots.In the following example, the regular expression \b[A-Z](\w*?\s*?){1,10}[.!?] matches sentences that contain between one and ten words. Elle établit une correspondance avec toutes les phrases de la chaîne d’entrée à l’exception d’une phrase qui contient 18 mots.It matches all the sentences in the input string except for one sentence that contains 18 words.

string pattern = @"\b[A-Z](\w*?\s*?){1,10}[.!?]";
string input = "Hi. I am writing a short note. Its purpose is " +
                      "to test a regular expression that attempts to find " +
                      "sentences with ten or fewer words. Most sentences " +
                      "in this note are short.";
foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);

//  The example displays the following output:
//        'Hi.' found at position 0.
//        'I am writing a short note.' found at position 4.
//        'Most sentences in this note are short.' found at position 132.
Dim pattern As String = "\b[A-Z](\w*\s?){1,10}?[.!?]"
Dim input As String = "Hi. I am writing a short note. Its purpose is " + _
                      "to test a regular expression that attempts to find " + _
                      "sentences with ten or fewer words. Most sentences " + _
                      "in this note are short."
For Each match As Match In Regex.Matches(input, pattern)
    Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'       'Hi.' found at position 0.
'       'I am writing a short note.' found at position 4.
'       'Most sentences in this note are short.' found at position 132.

Le modèle d’expression régulière est défini comme indiqué dans le tableau suivant.The regular expression pattern is defined as shown in the following table.

ModèlePattern DescriptionDescription
\b Commencer à la limite d'un mot.Start at a word boundary.
[A-Z] Mettre en correspondance une majuscule de A à Z.Match an uppercase character from A to Z.
(\w*?\s*?) Mettre en correspondance zéro, un ou plusieurs caractères alphabétiques, suivis d’un ou plusieurs espaces, mais le moins de fois possible.Match zero or more word characters, followed by one or more white-space characters, but as few times as possible. Il s’agit du premier groupe de capture.This is the first capture group.
{1,10} Mettre en correspondance le modèle précédent entre 1 et 10 fois.Match the previous pattern between 1 and 10 times.
[.!?] Mettre en correspondance un signe de ponctuation « . », « ! » ou « ? ».Match any one of the punctuation characters ".", "!", or "?".

Quantificateurs gourmands et paresseuxGreedy and Lazy Quantifiers

De nombreux quantificateurs existent en deux versions :A number of the quantifiers have two versions:

  • Une version gourmande.A greedy version.

    Un quantificateur gourmand essaie de correspondre à un élément autant de fois que possible.A greedy quantifier tries to match an element as many times as possible.

  • Une version non gourmande (ou paresseuse).A non-greedy (or lazy) version.

    Un quantificateur non gourmand essaie de correspondre à un élément aussi peu de fois que possible.A non-greedy quantifier tries to match an element as few times as possible. Vous pouvez changer un quantificateur gourmand en quantificateur paresseux en ajoutant simplement un ?.You can turn a greedy quantifier into a lazy quantifier by simply adding a ?.

Considérez une expression régulière simple censée extraire les quatre derniers chiffres d’une chaîne de nombres telle qu’un numéro de carte de crédit.Consider a simple regular expression that is intended to extract the last four digits from a string of numbers such as a credit card number. La version de l’expression régulière qui utilise le quantificateur gourmand * est \b.*([0-9]{4})\b.The version of the regular expression that uses the * greedy quantifier is \b.*([0-9]{4})\b. Toutefois, si une chaîne contient deux nombres, cette expression régulière correspond uniquement aux quatre derniers chiffres du deuxième nombre, comme le montre l’exemple suivant.However, if a string contains two numbers, this regular expression matches the last four digits of the second number only, as the following example shows.

string greedyPattern = @"\b.*([0-9]{4})\b";
string input1 = "1112223333 3992991999";
foreach (Match match in Regex.Matches(input1, greedyPattern))
   Console.WriteLine("Account ending in ******{0}.", match.Groups[1].Value);

// The example displays the following output:
//       Account ending in ******1999.
Dim greedyPattern As String = "\b.*([0-9]{4})\b"
Dim input1 As String = "1112223333 3992991999"
For Each match As Match In Regex.Matches(input1, greedypattern)
    Console.WriteLine("Account ending in ******{0}.", match.Groups(1).Value)
Next
' The example displays the following output:
'       Account ending in ******1999.

L’expression régulière ne parvient pas à établir de correspondance avec le premier nombre ; en effet, comme le quantificateur * tente d’établir une correspondance autant de fois que possible avec l’élément qui précède dans la totalité de la chaîne, il trouve une correspondance à la fin de celle-ci.The regular expression fails to match the first number because the * quantifier tries to match the previous element as many times as possible in the entire string, and so it finds its match at the end of the string.

Il ne s’agit pas du comportement souhaité.This is not the desired behavior. Vous pouvez plutôt utiliser le quantificateur paresseux *? pour extraire les chiffres des deux nombres, comme le montre l’exemple suivant.Instead, you can use the *?lazy quantifier to extract digits from both numbers, as the following example shows.

string lazyPattern = @"\b.*?([0-9]{4})\b";
string input2 = "1112223333 3992991999";
foreach (Match match in Regex.Matches(input2, lazyPattern))
   Console.WriteLine("Account ending in ******{0}.", match.Groups[1].Value);

// The example displays the following output:
//       Account ending in ******3333.
//       Account ending in ******1999.
Dim lazyPattern As String = "\b.*?([0-9]{4})\b"
Dim input2 As String = "1112223333 3992991999"
For Each match As Match In Regex.Matches(input2, lazypattern)
    Console.WriteLine("Account ending in ******{0}.", match.Groups(1).Value)
Next
' The example displays the following output:
'       Account ending in ******3333.
'       Account ending in ******1999.

Dans la plupart des cas, les expressions régulières avec des quantificateurs gourmands et paresseux retournent les mêmes correspondances.In most cases, regular expressions with greedy and lazy quantifiers return the same matches. Elles retournent le plus souvent des résultats différents quand elles sont utilisées avec le métacaractère (.) générique, qui correspond à n’importe quel caractère.They most commonly return different results when they are used with the wildcard (.) metacharacter, which matches any character.

Quantificateurs et correspondances videsQuantifiers and Empty Matches

Les quantificateurs * , + et { n , m } et leurs équivalents paresseux ne se répètent jamais après une correspondance vide quand le nombre minimal de captures a été trouvé.The quantifiers *, +, and {n,m} and their lazy counterparts never repeat after an empty match when the minimum number of captures has been found. Cette règle empêche les quantificateurs d’entrer dans des boucles infinies sur des correspondances de sous-expressions vides quand le nombre maximal de captures de groupe possibles est infini ou proche de l’infini.This rule prevents quantifiers from entering infinite loops on empty subexpression matches when the maximum number of possible group captures is infinite or near infinite.

Par exemple, le code suivant montre le résultat d’un appel de la méthode Regex.Match avec le modèle d’expression régulière (a?)* qui correspond à zéro ou un caractère « a », zéro, une ou plusieurs fois.For example, the following code shows the result of a call to the Regex.Match method with the regular expression pattern (a?)*, which matches zero or one "a" character zero or more times. Notez que le seul groupe de capture capture chaque « a », ainsi que String.Empty, mais qu’il n’existe aucune deuxième correspondance vide, car la première correspondance vide entraîne l’arrêt de la répétition du quantificateur.Note that the single capturing group captures each "a" as well as String.Empty, but that there is no second empty match, because the first empty match causes the quantifier to stop repeating.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(a?)*";
      string input = "aaabbb";
      Match match = Regex.Match(input, pattern);
      Console.WriteLine("Match: '{0}' at index {1}",
                        match.Value, match.Index);
      if (match.Groups.Count > 1) {
         GroupCollection groups = match.Groups;
         for (int grpCtr = 1; grpCtr <= groups.Count - 1; grpCtr++) {
            Console.WriteLine("   Group {0}: '{1}' at index {2}",
                              grpCtr,
                              groups[grpCtr].Value,
                              groups[grpCtr].Index);
            int captureCtr = 0;
            foreach (Capture capture in groups[grpCtr].Captures) {
               captureCtr++;
               Console.WriteLine("      Capture {0}: '{1}' at index {2}",
                                 captureCtr, capture.Value, capture.Index);
            }
         }
      }
   }
}
// The example displays the following output:
//       Match: 'aaa' at index 0
//          Group 1: '' at index 3
//             Capture 1: 'a' at index 0
//             Capture 2: 'a' at index 1
//             Capture 3: 'a' at index 2
//             Capture 4: '' at index 3
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "(a?)*"
        Dim input As String = "aaabbb"
        Dim match As Match = Regex.Match(input, pattern)
        Console.WriteLine("Match: '{0}' at index {1}",
                          match.Value, match.Index)
        If match.Groups.Count > 1 Then
            Dim groups As GroupCollection = match.Groups
            For grpCtr As Integer = 1 To groups.Count - 1
                Console.WriteLine("   Group {0}: '{1}' at index {2}",
                                  grpCtr,
                                  groups(grpCtr).Value,
                                  groups(grpCtr).Index)
                Dim captureCtr As Integer = 0
                For Each capture As Capture In groups(grpCtr).Captures
                    captureCtr += 1
                    Console.WriteLine("      Capture {0}: '{1}' at index {2}",
                                      captureCtr, capture.Value, capture.Index)
                Next
            Next
        End If
    End Sub
End Module
' The example displays the following output:
'       Match: 'aaa' at index 0
'          Group 1: '' at index 3
'             Capture 1: 'a' at index 0
'             Capture 2: 'a' at index 1
'             Capture 3: 'a' at index 2
'             Capture 4: '' at index 3

Pour voir la différence pratique entre un groupe de capture qui définit un nombre minimal et un nombre maximal de captures et un groupe de capture qui définit un nombre fixe de captures, examinez les modèles d’expressions régulières (a\1|(?(1)\1)){0,2} et (a\1|(?(1)\1)){2}.To see the practical difference between a capturing group that defines a minimum and a maximum number of captures and one that defines a fixed number of captures, consider the regular expression patterns (a\1|(?(1)\1)){0,2} and (a\1|(?(1)\1)){2}. Les deux expressions régulières se composent d’un seul groupe de capture, qui est défini comme indiqué dans le tableau suivant.Both regular expressions consist of a single capturing group, which is defined as shown in the following table.

ModèlePattern DescriptionDescription
(a\1 Mettre en correspondance « a » avec la valeur du premier groupe capturé …Either match "a" along with the value of the first captured group …
|(?(1) ou tester si le premier groupe capturé a été défini.or test whether the first captured group has been defined. (Notez que la construction (?(1) ne définit pas un groupe de capture.)(Note that the (?(1) construct does not define a capturing group.)
\1)) Si le premier groupe capturé existe, établir une correspondance avec sa valeur.If the first captured group exists, match its value. Si le groupe n’existe pas, le groupe correspond à String.Empty.If the group does not exist, the group will match String.Empty.

La première expression régulière essaie de correspondre à ce modèle entre zéro et deux fois ; la deuxième, exactement deux fois.The first regular expression tries to match this pattern between zero and two times; the second, exactly two times. Étant donné que le premier modèle atteint son nombre minimal de captures avec sa première capture de String.Empty, il ne se répète jamais pour essayer d’établir une correspondance avec a\1 ; le quantificateur {0,2} autorise uniquement les correspondances vides dans la dernière itération.Because the first pattern reaches its minimum number of captures with its first capture of String.Empty, it never repeats to try to match a\1; the {0,2} quantifier allows only empty matches in the last iteration. En revanche, la seconde expression régulière établit une correspondance avec « a », car elle évalue a\1 une deuxième fois ; le nombre minimal d’itérations, 2, entraîne la répétition du moteur après une correspondance vide.In contrast, the second regular expression does match "a" because it evaluates a\1 a second time; the minimum number of iterations, 2, forces the engine to repeat after an empty match.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern, input;

      pattern = @"(a\1|(?(1)\1)){0,2}";
      input = "aaabbb";

      Console.WriteLine("Regex pattern: {0}", pattern);
      Match match = Regex.Match(input, pattern);
      Console.WriteLine("Match: '{0}' at position {1}.",
                        match.Value, match.Index);
      if (match.Groups.Count > 1) {
         for (int groupCtr = 1; groupCtr <= match.Groups.Count - 1; groupCtr++)
         {
            Group group = match.Groups[groupCtr];
            Console.WriteLine("   Group: {0}: '{1}' at position {2}.",
                              groupCtr, group.Value, group.Index);
            int captureCtr = 0;
            foreach (Capture capture in group.Captures) {
               captureCtr++;
               Console.WriteLine("      Capture: {0}: '{1}' at position {2}.",
                                 captureCtr, capture.Value, capture.Index);
            }
         }
      }
      Console.WriteLine();

      pattern = @"(a\1|(?(1)\1)){2}";
      Console.WriteLine("Regex pattern: {0}", pattern);
      match = Regex.Match(input, pattern);
         Console.WriteLine("Matched '{0}' at position {1}.",
                           match.Value, match.Index);
      if (match.Groups.Count > 1) {
         for (int groupCtr = 1; groupCtr <= match.Groups.Count - 1; groupCtr++)
         {
            Group group = match.Groups[groupCtr];
            Console.WriteLine("   Group: {0}: '{1}' at position {2}.",
                              groupCtr, group.Value, group.Index);
            int captureCtr = 0;
            foreach (Capture capture in group.Captures) {
               captureCtr++;
               Console.WriteLine("      Capture: {0}: '{1}' at position {2}.",
                                 captureCtr, capture.Value, capture.Index);
            }
         }
      }
   }
}
// The example displays the following output:
//       Regex pattern: (a\1|(?(1)\1)){0,2}
//       Match: '' at position 0.
//          Group: 1: '' at position 0.
//             Capture: 1: '' at position 0.
//
//       Regex pattern: (a\1|(?(1)\1)){2}
//       Matched 'a' at position 0.
//          Group: 1: 'a' at position 0.
//             Capture: 1: '' at position 0.
//             Capture: 2: 'a' at position 0.
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern, input As String

        pattern = "(a\1|(?(1)\1)){0,2}"
        input = "aaabbb"

        Console.WriteLine("Regex pattern: {0}", pattern)
        Dim match As Match = Regex.Match(input, pattern)
        Console.WriteLine("Match: '{0}' at position {1}.",
                          match.Value, match.Index)
        If match.Groups.Count > 1 Then
            For groupCtr As Integer = 1 To match.Groups.Count - 1
                Dim group As Group = match.Groups(groupCtr)
                Console.WriteLine("   Group: {0}: '{1}' at position {2}.",
                                  groupCtr, group.Value, group.Index)
                Dim captureCtr As Integer = 0
                For Each capture As Capture In group.Captures
                    captureCtr += 1
                    Console.WriteLine("      Capture: {0}: '{1}' at position {2}.",
                                      captureCtr, capture.Value, capture.Index)
                Next
            Next
        End If
        Console.WriteLine()

        pattern = "(a\1|(?(1)\1)){2}"
        Console.WriteLine("Regex pattern: {0}", pattern)
        match = Regex.Match(input, pattern)
        Console.WriteLine("Matched '{0}' at position {1}.",
                          match.Value, match.Index)
        If match.Groups.Count > 1 Then
            For groupCtr As Integer = 1 To match.Groups.Count - 1
                Dim group As Group = match.Groups(groupCtr)
                Console.WriteLine("   Group: {0}: '{1}' at position {2}.",
                                  groupCtr, group.Value, group.Index)
                Dim captureCtr As Integer = 0
                For Each capture As Capture In group.Captures
                    captureCtr += 1
                    Console.WriteLine("      Capture: {0}: '{1}' at position {2}.",
                                      captureCtr, capture.Value, capture.Index)
                Next
            Next
        End If
    End Sub
End Module
' The example displays the following output:
'       Regex pattern: (a\1|(?(1)\1)){0,2}
'       Match: '' at position 0.
'          Group: 1: '' at position 0.
'             Capture: 1: '' at position 0.
'       
'       Regex pattern: (a\1|(?(1)\1)){2}
'       Matched 'a' at position 0.
'          Group: 1: 'a' at position 0.
'             Capture: 1: '' at position 0.
'             Capture: 2: 'a' at position 0.

Voir aussiSee also