Exportar (0) Imprimir
Expandir Tudo
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original

Quantificadores

Quantificadores especificar quantas instâncias do elemento anterior (que pode ser um caractere, um agrupar ou uma classe de caracteres) devem estar presentes na entrada para uma correspondência ser localizado.

A tabela a seguir lista quantificadores suportados pelo .NET estrutura expressões regulares. As n e m quantidades são constantes inteiras. Para obter uma descrição da diferença entre lentas e greedy quantificadores, consulte a seção "Greedy e lento quantificadores" que segue a tabela.

Quantificador

Descrição

*

Corresponde ao elemento precedente zero ou mais vezes. É equivalente a {0}. * é um quantificador greedy cujo equivalente não greedy é *?.

Por exemplo, a expressão regular \b91*9*\b tenta corresponder o dígito 9 Após um limite de palavra. 9 pode ser seguido de zero ou mais instâncias do dígito 1, que por sua vez pode ser seguido por zero ou mais instâncias do dígito 9. O exemplo a seguir ilustra essa expressão regular. De nove dígitos na seqüência de caracteres de entrada, cinco coincidir com o padrão e quatro (95, 929, 9129, e 9919), não.

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.


+

Coincide com o elemento anterior um ou mais vezes. É equivalente a {1,}. + é um quantificador greedy cujo equivalente não greedy é +?.

Por exemplo, a expressão regular \ba(n)+\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. A expressão regular corresponde a palavras an, annual, announcement, e antiquee falhar corretamente corresponder à autumn e all.

string pattern = @"\ba(n)+\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.      


?

Coincide com o time de elemento zero ou um anterior. É equivalente a {0,1}. ? é um quantificador greedy cujo equivalente não greedy é ??.

Por exemplo, a expressão regular \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 o palavras a e an. O exemplo a seguir ilustra essa expressão regular.

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.


{ n }

Coincide com o elemento anterior exatamente n horários. {n} é um quantificador greedy cujo equivalente não greedy é {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 Decimal, seguidos de três dígitos seguidos de um limite de palavra. O exemplo a seguir ilustra essa expressão regular.

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.


{ n ,}

Coincide pelo menos o elemento anterior n horários. {n,} é um quantificador greedy cujo equivalente não greedy é {n}?.

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


{ n , m }

Coincide pelo menos o elemento anterior n, mas não mais de m, horas. {n,m} é um quantificador greedy cujo equivalente não greedy é {n,m}?.

Por exemplo, a expressão regular (00\s){2,4} tenta corresponder a zero dígitos seguidos por um espaço entre dois e quatro ocorrências de dois. O exemplo a seguir ilustra essa expressão regular. Observe que a parte final da seqüência de caracteres de entrada inclui este padrão de cinco vezes em vez do máximo de quatro. No entanto, a parte inicial desse substring (até o espaço e o quinto emparelhar de zeros) encontra o padrão de expressão regular.

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.


*?

Coincide com o elemento anterior zero ou mais vezes, mas sistema autônomo algumas vezes sistema autônomo possíveis. É um quantificador lazy é a contraparte o quantificador greedy *.

Por exemplo, a expressão regular \b\w*?oo\w*? \b matches all words that contain the string oo. O exemplo a seguir ilustra essa expressão regular.

 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.


+?

Coincide com o elemento anterior um ou mais vezes, mas sistema autônomo algumas vezes sistema autônomo possíveis. É um quantificador lazy é a contraparte o quantificador greedy +.

Por exemplo, a expressão regular \b\w+? \b matches one or more characters separated by word boundaries. O exemplo a seguir ilustra essa expressão regular.

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.


??

Coincide com o time de elemento zero ou uma anterior, mas, algumas vezes possível. É um quantificador lazy é a contraparte o quantificador greedy ?.

Por exemplo, a expressão regular ^(\s)*(System.)??Console.Write(Line)?? \(?? attempts to match the strings Console.Write or Console.WriteLine. A seqüência de caracteres também pode incluir System. antes de Console, e pode ser seguido por um parêntese de abertura. A seqüência de caracteres deve ser no início de uma linha, embora possa ser precedido por espaço em branco. O exemplo a seguir ilustra essa expressão regular.

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.


{ n }?

Coincide com o elemento anterior exatamente n horários. É um quantificador lazy é o contador para o quantificador greedy {n}+.

Por exemplo, a expressão regular \b(\w{3,}? \.){2}? \w{3,}? \b matches exactly two sets of characters followed by a period on a word boundary. Em seguida, ele é seguido de outro conjunto de caracteres e um limite de palavra. Essa expressão regular deve identificar o endereço do site. O exemplo a seguir ilustra a expressão regular. Observe que corresponde ao www.microsoft.com e mdsn.microsoft.com, mas não corresponde mywebsite ou 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.


{ n ,}?

Coincide com o elemento anterior no lesistema autônomot n horários, mas sistema autônomo algumas vezes sistema autônomo possíveis. É um quantificador lazy é a contraparte o quantificador greedy {n,}.

Consulte o exemplo para o {n}? quantificador para uma ilustração. A expressão regular esse exemplo usa o {n,} quantificador para coincidir com uma seqüência que tenha pelo menos três caracteres seguidos por um período.

{ n , m }?

Coincide com o elemento anterior entre n e m horários, mas sistema autônomo algumas vezes sistema autônomo possíveis. É um quantificador lazy é a contraparte o quantificador greedy {n,m}.

Por exemplo, a expressão regular \b[A-Z](\w*? \s*?){1,10}[.!?] matches sentences that contain between one and ten words. Ele coincide com um limite de palavra seguido por uma letra maiúscula seguida entre um e dez repetições de zero ou mais caracteres de palavra e, opcionalmente, um caractere de espaço. Em seguida, a correspondência é encerrada por um período, um ponto de exclamação ou um ponto de interrogação. O exemplo a seguir ilustra essa expressão regular. Corresponder a todas as frases na seqüência de caracteres de entrada, exceto para uma única sentença que contenha 18 palavras.

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.


Um número das quantificadores tem duas versões:

  • Uma versão greedy.

    Um quantificador greedy tenta corresponder o elemento que ela se aplica ao sistema autônomo muitas vezes sistema autônomo possíveis.

  • Uma versão não greedy (ou lenta).

    Um quantificador não greedy tenta corresponder o elemento que ela se aplica ao sistema autônomo algumas vezes possível.

Para ilustrar a diferença, considere uma expressão regular muito simplista que se destina a extrair sistema autônomo quatro últimos dígitos de uma seqüência de números, sistema autônomo um número de cartão de crédito. A versão de expressão regular que usa o * quantificador greedy é \b.*([0-9]{4})\b. No entanto, dada uma seqüência de caracteres que contém dois números, conseguir exibir somente sistema autônomo quatro últimos dígitos do número da segundo, conforme mostrado no exemplo a seguir.

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.


Isso não é o comportamento desejado. A expressão regular não corresponde ao número primeiro porque o * quantificador tenta corresponder o elemento anterior sistema autônomo muitas vezes sistema autônomo possível em toda a seqüência de caracteres, e, portanto, encontrar sua correspondência no participante da seqüência de caracteres.

No entanto, uma expressão regular equivalente que utiliza o *?quantificador lazy produz o comportamento esperado, sistema autônomo mostra o exemplo a seguir.

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.


Na maioria dos casos, as expressões regulares com quantificadores greedy e lentas retornam correspondências mesmas. Eles geralmente retornam resultados diferentes quando usado com o período (. ) metacharacter, which matches any character.


Data

História

Motivo

Julho de 2008

Revisado exaustivamente.

Correção de bug do conteúdo.

Contribuições da comunidade

ADICIONAR
Mostrar:
© 2014 Microsoft