Quantificadores em expressões regularesQuantifiers in Regular Expressions

Os quantificadores especificam quantas instâncias de um caractere, grupo ou classe de caracteres devem estar presentes na entrada para encontrar uma correspondência.Quantifiers specify how many instances of a character, group, or character class must be present in the input for a match to be found. A tabela a seguir lista os quantificadores tem suporte no .NET.The following table lists the quantifiers supported by .NET.

Quantificador GreedyGreedy quantifier Quantificador lentoLazy quantifier DESCRIÇÃODescription
* *? Corresponder a zero ou mais vezes.Match zero or more times.
+ +? Corresponder a um ou mais vezes.Match one or more times.
? ?? Corresponder a zero ou uma vez.Match zero or one time.
{ n }{ n } { n }?{ n }? Corresponde exatamente a n vezes.Match exactly n times.
{ n ,}{ n ,} { n ,}?{ n ,}? Corresponde a, pelo menos, n vezes.Match at least n times.
{ n , m }{ n , m } { n , m }?{ n , m }? Corresponde de n a m vezes.Match from n to m times.

As quantidades n e m são constantes inteiras.The quantities n and m are integer constants. Normalmente, os quantificadores são Greedy; eles fazem com que o mecanismo de expressões regulares corresponda a quantas ocorrências de padrões determinados forem possíveis.Ordinarily, quantifiers are greedy; they cause the regular expression engine to match as many occurrences of particular patterns as possible. Acrescentar o caractere ? a um quantificador o torna lento; faz com que o mecanismo de expressões regulares corresponda ao mínimo de ocorrências possíveis.Appending the ? character to a quantifier makes it lazy; it causes the regular expression engine to match as few occurrences as possible. Para obter uma descrição completa da diferença entre quantificadores Greedy e lentos, consulte a seção Quantificadores Greedy e lentos mais adiante neste tópico.For a complete description of the difference between greedy and lazy quantifiers, see the section Greedy and Lazy Quantifiers later in this topic.

Importante

O aninhamento de quantificadores (por exemplo, como o padrão de expressão regular (a*)* faz) pode aumentar o número de comparações que o mecanismo de expressões regulares deve executar, como uma função exponencial do número de caracteres na cadeia de caracteres de entrada.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. Para saber mais sobre esse comportamento e suas soluções, veja Retrocesso.For more information about this behavior and its workarounds, see Backtracking.

Quantificadores em expressões regularesRegular Expression Quantifiers

As seções a seguir listam os quantificadores com suporte nas expressões regulares no .NET.The following sections list the quantifiers supported by .NET regular expressions.

Observação

Se os caracteres *, +, ?, { e } forem encontrados em um padrão de expressão regular, o mecanismo de expressões regulares vai interpretá-los como quantificadores ou parte de constructos de quantificador, exceto se estiverem incluídos em uma classe de caracteres.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. Para interpretá-los como caracteres literais fora de uma classe de caracteres, você precisa fazer o escape, antecedendo-os com uma barra invertida.To interpret these as literal characters outside a character class, you must escape them by preceding them with a backslash. Por exemplo, a cadeia de caracteres \* em um padrão de expressão regular é interpretada como um caractere asterisco ("*") integral.For example, the string \* in a regular expression pattern is interpreted as a literal asterisk ("*") character.

Corresponder a zero ou mais vezes: *Match Zero or More Times: *

O quantificador * corresponde ao elemento anterior zero ou mais vezes.The * quantifier matches the preceding element zero or more times. É equivalente ao quantificador {0,}.It is equivalent to the {0,} quantifier. * é um quantificador Greedy, cujo equivalente lento é *?.* is a greedy quantifier whose lazy equivalent is *?.

O exemplo a seguir ilustra essa expressão regular.The following example illustrates this regular expression. Dentre os nove dígitos na cadeia de caracteres de entrada, cinco correspondem ao padrão e quatro (95, 929, 9219 e 9919) não.Of the nine digits 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.

O padrão de expressão regular é definido como mostra a tabela a seguir.The regular expression pattern is defined as shown in the following table.

PadrãoPattern DESCRIÇÃODescription
\b Iniciar em um limite de palavra.Start at a word boundary.
91* Corresponder a “9” seguido por zero ou mais caracteres “1”.Match a "9" followed by zero or more "1" characters.
9* Corresponder a zero ou mais caracteres “9”.Match zero or more "9" characters.
\b Terminar em um limite de palavra.End at a word boundary.

Corresponder a um ou mais vezes: +Match One or More Times: +

O quantificador + corresponde ao elemento anterior uma ou mais vezes.The + quantifier matches the preceding element one or more times. É equivalente a {1,}.It is equivalent to {1,}. + é um quantificador Greedy, cujo equivalente lento é +?.+ is a greedy quantifier whose lazy equivalent is +?.

Por exemplo, a expressão regular \ban+\w*?\b tenta corresponder a palavras inteiras que começam com a letra a seguidas por uma ou mais instâncias da letra 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. O exemplo a seguir ilustra essa expressão regular.The following example illustrates this regular expression. A expressão regular corresponde às palavras an, annual, announcement e antique, e não correspondem corretamente a autumn e 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.      

O padrão de expressão regular é definido como mostra a tabela a seguir.The regular expression pattern is defined as shown in the following table.

PadrãoPattern DESCRIÇÃODescription
\b Iniciar em um limite de palavra.Start at a word boundary.
an+ Corresponder a um “a” seguido por um ou mais caracteres “n”.Match an "a" followed by one or more "n" characters.
\w*? Corresponder a um caractere de palavra zero ou mais vezes, mas o menor número de vezes possível.Match a word character zero or more times, but as few times as possible.
\b Terminar em um limite de palavra.End at a word boundary.

Corresponder a zero ou uma vez: ?Match Zero or One Time: ?

O quantificador ? corresponde ao elemento anterior zero ou uma vez.The ? quantifier matches the preceding element zero or one time. É equivalente a {0,1}.It is equivalent to {0,1}. ? é um quantificador Greedy, cujo equivalente lento é ??.? is a greedy quantifier whose lazy equivalent is ??.

Por exemplo, a expressão regular \ban?\b tenta corresponder a palavras inteiras que começam com a letra a seguidas por zero ou uma instância da letra 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. Em outras palavras, ele tenta corresponder às palavras a e an.In other words, it tries to match the words a and an. O exemplo a seguir ilustra essa expressão regular.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.

O padrão de expressão regular é definido como mostra a tabela a seguir.The regular expression pattern is defined as shown in the following table.

PadrãoPattern DESCRIÇÃODescription
\b Iniciar em um limite de palavra.Start at a word boundary.
an? Corresponder a um “a” seguido por zero ou um caractere “n”.Match an "a" followed by zero or one "n" character.
\b Terminar em um limite de palavra.End at a word boundary.

Corresponder exatamente a n vezes: {n}Match Exactly n Times: {n}

O quantificador {n} corresponde ao elemento anterior exatamente n vezes, em que n é qualquer inteiro.The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} é um quantificador Greedy cujo equivalente lento é {n}?.{n} is a greedy quantifier whose lazy equivalent is {n}?.

Por exemplo, a expressão regular \b\d+\,\d{3}\b tenta corresponder a um limite de palavra seguido por um ou mais dígitos decimais seguidos por três dígitos decimais seguidos por um limite de palavra.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. O exemplo a seguir ilustra essa expressão regular.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.

O padrão de expressão regular é definido como mostra a tabela a seguir.The regular expression pattern is defined as shown in the following table.

PadrãoPattern DESCRIÇÃODescription
\b Iniciar em um limite de palavra.Start at a word boundary.
\d+ Corresponde a um ou mais dígitos decimais.Match one or more decimal digits.
\, Corresponder a um caractere de vírgula.Match a comma character.
\d{3} Corresponder a três dígitos decimais.Match three decimal digits.
\b Terminar em um limite de palavra.End at a word boundary.

Corresponder a pelo menos n vezes: {n,}Match at Least n Times: {n,}

O quantificador {n,} corresponde ao elemento anterior pelo menos n vezes, em que n é qualquer inteiro.The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} é um quantificador Greedy cujo equivalente lento é {n,}?.{n,} is a greedy quantifier whose lazy equivalent is {n,}?.

Por exemplo, a expressão regular \b\d{2,}\b\D+ tenta corresponder a um limite de palavra seguido por pelo menos dois dígitos seguidos por um limite de palavra e um caractere não dígito.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. O exemplo a seguir ilustra essa expressão regular.The following example illustrates this regular expression. A expressão regular não corresponde à frase "7 days" porque contém apenas um dígito decimal, mas corresponde com êxito às frases "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.

O padrão de expressão regular é definido como mostra a tabela a seguir.The regular expression pattern is defined as shown in the following table.

PadrãoPattern DESCRIÇÃODescription
\b Iniciar em um limite de palavra.Start at a word boundary.
\d{2,} Corresponder a pelo menos dois dígitos decimais.Match at least two decimal digits.
\b Corresponder a um limite de palavra.Match a word boundary.
\D+ Corresponder a pelo menos uma casa não decimal.Match at least one non-decimal digit.

Corresponder entre n e m vezes: {n,m}Match Between n and m Times: {n,m}

O quantificador {n,m} corresponde ao elemento anterior pelo menos n vezes, mas não mais de m vezes, em que n e m são inteiros.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} é um quantificador Greedy cujo equivalente lento é {n,m}?.{n,m} is a greedy quantifier whose lazy equivalent is {n,m}?.

No exemplo a seguir, a expressão regular (00\s){2,4} tenta corresponder a entre duas e quatro ocorrências de dois dígitos zero seguidos por um espaço.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. Observe que a parte final da cadeia de caracteres de entrada inclui esse padrão de cinco vezes em vez de no máximo quatro.Note that the final portion of the input string includes this pattern five times rather than the maximum of four. No entanto, apenas a parte inicial dessa subcadeia de caracteres (até o espaço e o quinto par de zeros) corresponde ao padrão de expressão regular.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.

Corresponder a zero ou mais vezes (correspondência lenta): *?Match Zero or More Times (Lazy Match): *?

O quantificador *? corresponde ao elemento anterior zero ou mais vezes, mas o menor número de vezes possível.The *? quantifier matches the preceding element zero or more times, but as few times as possible. É a contraparte lenta do quantificador Greedy *.It is the lazy counterpart of the greedy quantifier *.

No exemplo a seguir, a expressão regular \b\w*?oo\w*?\b corresponde a todas as palavras que contêm a cadeia de caracteres 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.

O padrão de expressão regular é definido como mostra a tabela a seguir.The regular expression pattern is defined as shown in the following table.

PadrãoPattern DESCRIÇÃODescription
\b Iniciar em um limite de palavra.Start at a word boundary.
\w*? Corresponder a zero ou mais caracteres de palavra, mas o menor número de caracteres possível.Match zero or more word characters, but as few characters as possible.
oo Corresponder à cadeia de caracteres “oo”.Match the string "oo".
\w*? Corresponder a zero ou mais caracteres de palavra, mas o menor número de caracteres possível.Match zero or more word characters, but as few characters as possible.
\b Terminar em um limite de palavra.End on a word boundary.

Corresponder a uma ou mais vezes (correspondência lenta): +?Match One or More Times (Lazy Match): +?

O quantificador +? corresponde ao elemento anterior uma ou mais vezes, mas o menor número de vezes possível.The +? quantifier matches the preceding element one or more times, but as few times as possible. É a contraparte lenta do quantificador Greedy +.It is the lazy counterpart of the greedy quantifier +.

Por exemplo, a expressão regular \b\w+?\b corresponde a um ou mais caracteres separados por limites de palavra.For example, the regular expression \b\w+?\b matches one or more characters separated by word boundaries. O exemplo a seguir ilustra essa expressão regular.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.

Corresponder a zero ou uma vez (correspondência lenta): ??Match Zero or One Time (Lazy Match): ??

O quantificador ?? corresponde ao elemento anterior zero ou uma vez, mas o menor número de vezes possível.The ?? quantifier matches the preceding element zero or one time, but as few times as possible. É a contraparte lenta do quantificador Greedy ?.It is the lazy counterpart of the greedy quantifier ?.

Por exemplo, a expressão regular ^\s*(System.)??Console.Write(Line)??\(?? tenta corresponder às cadeias de caracteres “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". A cadeia de caracteres também pode incluir "System."The string can also include "System." antes de “Console” e pode ser seguida por um parêntese de abertura.before "Console", and it can be followed by an opening parenthesis. A cadeia de caracteres deve estar no início de uma linha, embora possa ser antecedida por espaço em branco.The string must be at the beginning of a line, although it can be preceded by white space. O exemplo a seguir ilustra essa expressão regular.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.

O padrão de expressão regular é definido como mostra a tabela a seguir.The regular expression pattern is defined as shown in the following table.

PadrãoPattern DESCRIÇÃODescription
^ Corresponder ao início do fluxo de entrada.Match the start of the input stream.
\s* Corresponder a zero ou mais caracteres de espaço em branco.Match zero or more white-space characters.
(System.)?? Corresponde a zero ou uma ocorrência da cadeia de caracteres “System.”.Match zero or one occurrence of the string "System.".
Console.Write Corresponder à cadeia de caracteres “Console.Write”.Match the string "Console.Write".
(Line)?? Corresponde a zero ou uma ocorrência da cadeia de caracteres “Line”.Match zero or one occurrence of the string "Line".
\(?? Corresponder a zero ou uma ocorrência do parêntese de abertura.Match zero or one occurrence of the opening parenthesis.

Corresponder exatamente a n vezes (correspondência lenta): {n}?Match Exactly n Times (Lazy Match): {n}?

O quantificador {n}? corresponde ao elemento anterior exatamente n vezes, em que n é qualquer inteiro.The {n}? quantifier matches the preceding element exactly n times, where n is any integer. É o equivalente lento do quantificador Greedy {n}.It is the lazy counterpart of the greedy quantifier {n}.

No exemplo a seguir, a expressão regular \b(\w{3,}?\.){2}?\w{3,}?\b é usada para identificar um endereço de site.In the following example, the regular expression \b(\w{3,}?\.){2}?\w{3,}?\b is used to identify a Web site address. Observe que corresponde a “www.microsoft.com” e “msdn.microsoft.com”, mas não corresponde a “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.

O padrão de expressão regular é definido como mostra a tabela a seguir.The regular expression pattern is defined as shown in the following table.

PadrãoPattern DESCRIÇÃODescription
\b Iniciar em um limite de palavra.Start at a word boundary.
(\w{3,}?\.) Corresponder a pelo menos três caracteres de palavra, mas o menor número de caracteres possível, seguido por um caractere de ponto.Match at least 3 word characters, but as few characters as possible, followed by a dot or period character. Este é o primeiro grupo de captura.This is the first capturing group.
(\w{3,}?\.){2}? Corresponder ao padrão no primeiro grupo duas vezes, mas o menor número de vezes possível.Match the pattern in the first group two times, but as few times as possible.
\b Termina a correspondência em um limite de palavra.End the match on a word boundary.

Corresponder a pelo menos n vezes (correspondência lenta): {n,}?Match at Least n Times (Lazy Match): {n,}?

O quantificador {n,}? corresponde ao elemento anterior pelo menos n vezes, em que n é qualquer inteiro, mas o menor número de vezes possível.The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. É o equivalente lento do quantificador Greedy {n,}.It is the lazy counterpart of the greedy quantifier {n,}.

Veja o exemplo do quantificador {n}? na seção anterior para obter uma ilustração.See the example for the {n}? quantifier in the previous section for an illustration. A expressão regular nesse exemplo usa o quantificador {n,} para corresponder a uma cadeia de caracteres que tem, pelo menos, três caracteres seguidos por um ponto final.The regular expression in that example uses the {n,} quantifier to match a string that has at least three characters followed by a period.

Corresponder entre n e m vezes (correspondência lenta): {n,m}?Match Between n and m Times (Lazy Match): {n,m}?

O quantificador {n,m}? corresponde ao elemento anterior entre n e m vezes, em que n e m são inteiros, mas o menor número de vezes possível.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. É o equivalente lento do quantificador Greedy {n,m}.It is the lazy counterpart of the greedy quantifier {n,m}.

No exemplo a seguir, a expressão regular \b[A-Z](\w*?\s*?){1,10}[.!?] corresponde a frases que contêm entre uma e dez palavras.In the following example, the regular expression \b[A-Z](\w*?\s*?){1,10}[.!?] matches sentences that contain between one and ten words. Corresponde a todas as frases na cadeia de caracteres de entrada, exceto por uma frase que contém 18 palavras.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.

O padrão de expressão regular é definido como mostra a tabela a seguir.The regular expression pattern is defined as shown in the following table.

PadrãoPattern DESCRIÇÃODescription
\b Iniciar em um limite de palavra.Start at a word boundary.
[A-Z] Corresponder a um caractere maiúscula de A a Z.Match an uppercase character from A to Z.
(\w*?\s*?) Corresponder a zero ou mais caracteres de palavra, seguidos por um ou mais caracteres de espaço em branco, mas o menor número de vezes possível.Match zero or more word characters, followed by one or more white-space characters, but as few times as possible. Este é o primeiro grupo de captura.This is the first capture group.
{1,10} Corresponder ao padrão anterior entre 1 e 10 vezes.Match the previous pattern between 1 and 10 times.
[.!?] Corresponder a qualquer um dos caracteres de pontuação “.”, “!” ou “?”.Match any one of the punctuation characters ".", "!", or "?".

Quantificadores Greedy e lentosGreedy and Lazy Quantifiers

Alguns quantificadores têm duas versões:A number of the quantifiers have two versions:

  • Uma versão Greedy.A greedy version.

    Um quantificador Greedy tenta corresponder a um elemento tantas vezes quanto possível.A greedy quantifier tries to match an element as many times as possible.

  • Uma versão não Greedy (ou lenta).A non-greedy (or lazy) version.

    Um quantificador não Greedy tenta corresponder a um elemento o menor número de vezes possível.A non-greedy quantifier tries to match an element as few times as possible. Você pode transformar um quantificador Greedy em um quantificador lento simplesmente adicionando um ?.You can turn a greedy quantifier into a lazy quantifier by simply adding a ?.

Considere uma expressão regular simples que se destina a extrair os últimos quatro dígitos de uma cadeia de caracteres de números, como um número de cartão de crédito.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. A versão da expressão regular que usa o quantificador Greedy * é \b.*([0-9]{4})\b.The version of the regular expression that uses the * greedy quantifier is \b.*([0-9]{4})\b. No entanto, se uma cadeia de caracteres contiver dois números, essa expressão regular corresponde aos últimos quatro dígitos do segundo número, como mostra o exemplo a seguir.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.

A expressão regular não corresponde ao primeiro número porque o quantificador * tenta corresponder ao elemento anterior tantas vezes quanto possível em toda a cadeia de caracteres e encontra sua correspondência no final da cadeia de caracteres.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.

Esse não é o comportamento desejado.This is not the desired behavior. Em vez disso, é possível usar o quantificador lento *? para extrair dígitos de ambos os números, como mostra o exemplo a seguir.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.

Na maioria dos casos, expressões regulares com quantificadores Greedy e lentos retornam as mesmas correspondências.In most cases, regular expressions with greedy and lazy quantifiers return the same matches. Geralmente retornam resultados diferentes quando são usadas com o metacaractere curinga (.), que corresponde a qualquer caractere.They most commonly return different results when they are used with the wildcard (.) metacharacter, which matches any character.

Quantificadores e correspondências vaziasQuantifiers and Empty Matches

Os quantificadores *, + e {n,m} e seus equivalentes lentos nunca se repetem depois de uma correspondência vazia quando o número mínimo de capturas foi encontrado.The quantifiers *, +, and {n,m} and their lazy counterparts never repeat after an empty match when the minimum number of captures has been found. Essa regra impede que quantificadores entrem em loops infinitos em correspondências vazias de subexpressão quando o número máximo de capturas de grupo possíveis é infinito ou quase infinito.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.

Por exemplo, o código a seguir mostra o resultado de uma chamada para o método Regex.Match com o padrão de expressão regular (a?)* que corresponde a zero ou a um caractere "a" zero ou mais vezes.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. Observe que o grupo de captura único captura cada “a” bem como String.Empty, mas que não há uma segunda correspondência vazia, porque a primeira correspondência vazia faz com que o quantificador pare de se repetir.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

Para ver a diferença prática entre um grupo de captura que define um número mínimo e máximo de captura e um que define um número fixo de capturas, considere os padrões de expressão regular (a\1|(?(1)\1)){0,2} e (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}. Ambas as expressões regulares consistem em um único grupo de captura, que é definido como mostrado na tabela a seguir.Both regular expressions consist of a single capturing group, which is defined as shown in the following table.

PadrãoPattern DESCRIÇÃODescription
(a\1 Faça qualquer correspondência a “a” juntamente com o valor do primeiro grupo capturado…Either match "a" along with the value of the first captured group …
|(?(1) ou teste se o primeiro grupo capturado foi definido.or test whether the first captured group has been defined. (Observe que o constructo (?(1) não define um grupo de captura).(Note that the (?(1) construct does not define a capturing group.)
\1)) Se o primeiro grupo capturado existir, faça uma correspondência ao valor.If the first captured group exists, match its value. Se o grupo não existir, será correspondente a String.Empty.If the group does not exist, the group will match String.Empty.

A primeira expressão regular tenta corresponder a esse padrão entre zero e duas vezes; a segunda, exatamente duas vezes.The first regular expression tries to match this pattern between zero and two times; the second, exactly two times. Como o primeiro padrão atinge o número mínimo de capturas com a primeira captura de String.Empty, ele nunca se repete para tentar corresponder a a\1; o quantificador {0,2} permite apenas correspondências vazias na última iteração.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. Por outro lado, a segunda expressão regular corresponde a “a” porque avalia a\1 uma segunda vez; o número mínimo de iterações, 2, força o mecanismo a se repetir após uma correspondência vazia.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.

Consulte tambémSee also