Opções de expressões regularesRegular Expression Options

Por padrão, a comparação de uma cadeia de caracteres de entrada com quaisquer caracteres literais em um padrão de expressão regular diferencia maiúsculas e minúsculas; o espaço em branco em um padrão de expressão regular é interpretado como caracteres de espaço em branco literais e os grupos de captura em uma expressão regular são nomeados implícita e explicitamente.By default, the comparison of an input string with any literal characters in a regular expression pattern is case sensitive, white space in a regular expression pattern is interpreted as literal white-space characters, and capturing groups in a regular expression are named implicitly as well as explicitly. É possível modificar esses e vários outros aspectos do comportamento de expressão regular especificando opções de expressões regulares.You can modify these and several other aspects of default regular expression behavior by specifying regular expression options. Essas opções, que estão listadas na tabela a seguir, podem ser incluídas embutidas como parte do padrão de expressão regular, ou podem ser fornecidas a um construtor de classe System.Text.RegularExpressions.Regex ou método de correspondência padrão estático como um valor de enumeração System.Text.RegularExpressions.RegexOptions.These options, which are listed in the following table, can be included inline as part of the regular expression pattern, or they can be supplied to a System.Text.RegularExpressions.Regex class constructor or static pattern matching method as a System.Text.RegularExpressions.RegexOptions enumeration value.

Membro de RegexOptionsRegexOptions member Caractere embutidoInline character EfeitoEffect
None Não disponívelNot available Use o comportamento padrão.Use default behavior. Para obter mais informações, consulte Opções padrão.For more information, see Default Options.
IgnoreCase i Use correspondência sem diferenciação de maiúsculas e minúsculas.Use case-insensitive matching. Para obter mais informações, consulte Correspondência sem diferenciação de maiúsculas e minúsculas.For more information, see Case-Insensitive Matching.
Multiline m Use o modo multilinha, em que ^ e $ correspondem com o início e o fim de cada linha (em vez do início e o fim da cadeia de caracteres de entrada).Use multiline mode, where ^ and $ match the beginning and end of each line (instead of the beginning and end of the input string). Para obter mais informações, consulte Modo multilinha.For more information, see Multiline Mode.
Singleline s Use o modo de linha única, em que o ponto (.) corresponde com todos os caracteres (em vez de todos os caracteres, exceto \n).Use single-line mode, where the period (.) matches every character (instead of every character except \n). Para obter mais informações, consulte Modo de linha única.For more information, see Singleline Mode.
ExplicitCapture n Não capture grupos sem nome.Do not capture unnamed groups. As únicas capturas válidas são grupos explicitamente nomeados ou numerados na forma (?<name> subexpression).The only valid captures are explicitly named or numbered groups of the form (?<name> subexpression). Para obter mais informações, consulte Apenas capturas explícitas.For more information, see Explicit Captures Only.
Compiled Não disponívelNot available Compile a expressão regular para um assembly.Compile the regular expression to an assembly. Para obter mais informações, consulte Expressões regulares compiladas.For more information, see Compiled Regular Expressions.
IgnorePatternWhitespace x Exclua um espaço em branco sem escape do padrão e habilite comentários após uma tecla de cerquilha (#).Exclude unescaped white space from the pattern, and enable comments after a number sign (#). Para obter mais informações, confira Ignorar espaço em branco.For more information, see Ignore White Space.
RightToLeft Não disponívelNot available Altera a direção da pesquisa.Change the search direction. A pesquisa se move da direita para a esquerda, em vez de da esquerda para a direita.Search moves from right to left instead of from left to right. Para obter mais informações, consulte Modo da direita para a esquerda.For more information, see Right-to-Left Mode.
ECMAScript Não disponívelNot available Habilite o comportamento em conformidade com ECMAScript para a expressão.Enable ECMAScript-compliant behavior for the expression. Para obter mais informações, consulte Comportamento de correspondência de ECMAScript.For more information, see ECMAScript Matching Behavior.
CultureInvariant Não disponívelNot available Ignorar diferenças culturais no idioma.Ignore cultural differences in language. Para obter mais informações, consulte Comparação usando cultura invariável.For more information, see Comparison Using the Invariant Culture.

Especificando as opçõesSpecifying the Options

É possível especificar opções para expressões regulares de uma destas três maneiras:You can specify options for regular expressions in one of three ways:

  • No parâmetro options de um construtor de classe System.Text.RegularExpressions.Regex ou método de correspondência padrão (Shared no Visual Basic) estático, como Regex.Regex(String, RegexOptions) ou Regex.Match(String, String, RegexOptions).In the options parameter of a System.Text.RegularExpressions.Regex class constructor or static (Shared in Visual Basic) pattern-matching method, such as Regex.Regex(String, RegexOptions) or Regex.Match(String, String, RegexOptions). O parâmetro options é uma combinação OR bit a bit de valores enumerados System.Text.RegularExpressions.RegexOptions.The options parameter is a bitwise OR combination of System.Text.RegularExpressions.RegexOptions enumerated values.

    Quando as opções são fornecidas a uma instância Regex mediante uso do parâmetro options de um construtor de classe, elas são atribuídas à propriedade System.Text.RegularExpressions.RegexOptions.When options are supplied to a Regex instance by using the options parameter of a class constructor, the options are assigned to the System.Text.RegularExpressions.RegexOptions property. No entanto, a propriedade System.Text.RegularExpressions.RegexOptions não reflete opções embutidas no próprio padrão de expressão regular.However, the System.Text.RegularExpressions.RegexOptions property does not reflect inline options in the regular expression pattern itself.

    O exemplo a seguir fornece uma ilustração.The following example provides an illustration. Ele usa o parâmetro options do método Regex.Match(String, String, RegexOptions) para habilitar correspondência sem diferenciação entre maiúsculas e minúsculas e ignorar espaço em branco do parâmetro ao identificar palavras que começam com a letra "d".It uses the options parameter of the Regex.Match(String, String, RegexOptions) method to enable case-insensitive matching and to ignore pattern white space when identifying words that begin with the letter "d".

    string pattern = @"d \w+ \s";
    string input = "Dogs are decidedly good pets.";
    RegexOptions options = RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace;
    
    foreach (Match match in Regex.Matches(input, pattern, options))
       Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
    // The example displays the following output:
    //    'Dogs // found at index 0.
    //    'decidedly // found at index 9.      
    
    Dim pattern As String = "d \w+ \s"
    Dim input As String = "Dogs are decidedly good pets."
    Dim options As RegexOptions = RegexOptions.IgnoreCase Or RegexOptions.IgnorePatternWhitespace
    
    For Each match As Match In Regex.Matches(input, pattern, options)
       Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
    Next
    ' The example displays the following output:
    '    'Dogs ' found at index 0.
    '    'decidedly ' found at index 9.      
    
  • Aplicando opções embutidas em um padrão de expressão regular com a sintaxe (?imnsx-imnsx).By applying inline options in a regular expression pattern with the syntax (?imnsx-imnsx). A opção se aplica ao padrão do ponto em que a opção é definida até o fim do padrão ou o ponto em que a opção tem é indefinida por outra opção embutida.The option applies to the pattern from the point that the option is defined to either the end of the pattern or to the point at which the option is undefined by another inline option. Observe que a propriedade System.Text.RegularExpressions.RegexOptions de uma instância Regex não reflete essas opções embutidas.Note that the System.Text.RegularExpressions.RegexOptions property of a Regex instance does not reflect these inline options. Para saber mais, confira o tópico Constructos diversos.For more information, see the Miscellaneous Constructs topic.

    O exemplo a seguir fornece uma ilustração.The following example provides an illustration. Ele usa opções embutidas para habilitar a correspondência sem diferenciação entre maiúsculas e minúsculas e ignorar o espaço em branco do padrão ao identificar palavras que começam com a letra “d”.It uses inline options to enable case-insensitive matching and to ignore pattern white space when identifying words that begin with the letter "d".

    string pattern = @"(?ix) d \w+ \s";
    string input = "Dogs are decidedly good pets.";
    
    foreach (Match match in Regex.Matches(input, pattern))
       Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
    // The example displays the following output:
    //    'Dogs // found at index 0.
    //    'decidedly // found at index 9.      
    
    Dim pattern As String = "\b(?ix) d \w+ \s"
    Dim input As String = "Dogs are decidedly good pets."
    
    For Each match As Match In Regex.Matches(input, pattern)
       Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
    Next
    ' The example displays the following output:
    '    'Dogs ' found at index 0.
    '    'decidedly ' found at index 9.      
    
  • Aplicando opções embutidas em um constructo de agrupamento em particular em um padrão de expressão regular com a sintaxe (?imnsx-imnsx:subexpressão).By applying inline options in a particular grouping construct in a regular expression pattern with the syntax (?imnsx-imnsx:subexpression). Nenhum sinal antes de um conjunto de opções ativa o conjunto; um sinal de subtração antes de um conjunto de opções desativa o conjunto.No sign before a set of options turns the set on; a minus sign before a set of options turns the set off. (? é uma parte fixa da sintaxe da construção de linguagem que é necessária se as opções estão habilitadas ou desabilitadas.) A opção se aplica somente a esse grupo.(? is a fixed part of the language construct's syntax that is required whether options are enabled or disabled.) The option applies only to that group. Para saber mais, confira Constructos de agrupamento.For more information, see Grouping Constructs.

    O exemplo a seguir fornece uma ilustração.The following example provides an illustration. Ele usa opções embutidas em um constructo de agrupamento para habilitar a correspondência sem diferenciação entre maiúsculas e minúsculas e ignorar espaço em branco do padrão ao identificar palavras que começam com a letra “d”.It uses inline options in a grouping construct to enable case-insensitive matching and to ignore pattern white space when identifying words that begin with the letter "d".

    string pattern = @"\b(?ix: d \w+)\s";
    string input = "Dogs are decidedly good pets.";
    
    foreach (Match match in Regex.Matches(input, pattern))
       Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
    // The example displays the following output:
    //    'Dogs // found at index 0.
    //    'decidedly // found at index 9.      
    
    Dim pattern As String = "\b(?ix: d \w+)\s"
    Dim input As String = "Dogs are decidedly good pets."
    
    For Each match As Match In Regex.Matches(input, pattern)
       Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
    Next
    ' The example displays the following output:
    '    'Dogs ' found at index 0.
    '    'decidedly ' found at index 9.      
    

Se as opções forem embutidas especificadas, um sinal de menos (-) antes de uma opção ou conjunto de opções desativa essas opções.If options are specified inline, a minus sign (-) before an option or set of options turns off those options. Por exemplo, a construção embutida (?ix-ms) ativa as opções RegexOptions.IgnoreCase e RegexOptions.IgnorePatternWhitespace e desativa as opções RegexOptions.Multiline e RegexOptions.Singleline.For example, the inline construct (?ix-ms) turns on the RegexOptions.IgnoreCase and RegexOptions.IgnorePatternWhitespace options and turns off the RegexOptions.Multiline and RegexOptions.Singleline options. Todas as opções de expressões regulares são desativadas por padrão.All regular expression options are turned off by default.

Observação

Se as opções de expressão regular especificadas no parâmetro options de uma chamada de construtor ou método entrar em conflito com as opções especificadas embutidas em um padrão de expressão regular, serão usadas as opções embutidas.If the regular expression options specified in the options parameter of a constructor or method call conflict with the options specified inline in a regular expression pattern, the inline options are used.

As cinco opções de expressão regular a seguir podem ser definidas com parâmetro de opções e embutidas:The following five regular expression options can be set both with the options parameter and inline:

As cinco opções de expressão regular a seguir podem ser definidas usando o parâmetro options, mas não podem ser definidas embutidas:The following five regular expression options can be set using the options parameter but cannot be set inline:

Determinando as opçõesDetermining the Options

É possível determinar que opções foram fornecidas a um objeto Regex quando ele tiver sido instanciado recuperando o valor da propriedade Regex.Options somente leitura.You can determine which options were provided to a Regex object when it was instantiated by retrieving the value of the read-only Regex.Options property. Essa propriedade é particularmente útil para determinar as opções definidas para uma expressão regular compilada criada pelo método Regex.CompileToAssembly.This property is particularly useful for determining the options that are defined for a compiled regular expression created by the Regex.CompileToAssembly method.

Para testar a presença de qualquer opção, exceto RegexOptions.None, realize uma operação AND com o valor da propriedade Regex.Options e o valor RegexOptions no qual você está interessado.To test for the presence of any option except RegexOptions.None, perform an AND operation with the value of the Regex.Options property and the RegexOptions value in which you are interested. Em seguida, teste se o resultado é igual ao valor de RegexOptions.Then test whether the result equals that RegexOptions value. O exemplo a seguir testa se a opção RegexOptions.IgnoreCase foi definida.The following example tests whether the RegexOptions.IgnoreCase option has been set.

if ((rgx.Options & RegexOptions.IgnoreCase) == RegexOptions.IgnoreCase)
   Console.WriteLine("Case-insensitive pattern comparison.");
else
   Console.WriteLine("Case-sensitive pattern comparison.");
If (rgx.Options And RegexOptions.IgnoreCase) = RegexOptions.IgnoreCase Then
   Console.WriteLine("Case-insensitive pattern comparison.")
Else
   Console.WriteLine("Case-sensitive pattern comparison.")
End If   

Para testar RegexOptions.None, determine se o valor da propriedade Regex.Options é igual a RegexOptions.None, como ilustra o exemplo a seguir.To test for RegexOptions.None, determine whether the value of the Regex.Options property is equal to RegexOptions.None, as the following example illustrates.

if (rgx.Options == RegexOptions.None)
   Console.WriteLine("No options have been set.");
If rgx.Options = RegexOptions.None Then
   Console.WriteLine("No options have been set.")
End If

As seções a seguir listam as opções com suporte na expressão regular no .NET.The following sections list the options supported by regular expression in .NET.

Opções padrãoDefault Options

A opção RegexOptions.None indica que nenhuma opção foi especificada, e o mecanismo de expressão regular usa seu comportamento padrão.The RegexOptions.None option indicates that no options have been specified, and the regular expression engine uses its default behavior. Isso inclui o seguinte:This includes the following:

  • O padrão é interpretado como canônico e não como uma expressão regular ECMAScript.The pattern is interpreted as a canonical rather than an ECMAScript regular expression.

  • O padrão da expressão regular é combinado na cadeia de caracteres de entrada da esquerda para a direita.The regular expression pattern is matched in the input string from left to right.

  • As comparações diferenciam maiúsculas de minúsculas.Comparisons are case-sensitive.

  • Os elementos de linguagem ^ e $ correspondem com o início e o fim da cadeia de caracteres de entrada.The ^ and $ language elements match the beginning and end of the input string.

  • O elemento de linguagem . corresponde com todos os caracteres, exceto \n.The . language element matches every character except \n.

  • Qualquer espaço em branco em um padrão de expressão regular é interpretado como caractere de espaço literal.Any white space in a regular expression pattern is interpreted as a literal space character.

  • As convenções da cultura atual são usadas ao comparar o padrão com a cadeia de caracteres de entrada.The conventions of the current culture are used when comparing the pattern to the input string.

  • Os grupos de capturas no padrão de expressão regular são implícitos e explícitos.Capturing groups in the regular expression pattern are implicit as well as explicit.

Observação

A opção RegexOptions.None não tem equivalente embutido.The RegexOptions.None option has no inline equivalent. Quando as opções de expressões regulares são embutidas aplicadas, o comportamento padrão é restaurado de modo opção a opção, desativando uma opção em particular.When regular expression options are applied inline, the default behavior is restored on an option-by-option basis, by turning a particular option off. Por exemplo, (?i) ativa a comparação sem diferenciar maiúsculas de minúsculas e (?-i) restaura a comparação que diferencia maiúsculas de minúsculas.For example, (?i) turns on case-insensitive comparison, and (?-i) restores the default case-sensitive comparison.

Como a opção RegexOptions.None representa o comportamento padrão do mecanismo de expressão regular, raramente, ela é explicitamente especificada em uma chamada de método.Because the RegexOptions.None option represents the default behavior of the regular expression engine, it is rarely explicitly specified in a method call. Em vez disso, é chamado um método de construtor ou de correspondência padrão estático sem um parâmetro options.A constructor or static pattern-matching method without an options parameter is called instead.

Voltar ao inícioBack to Top

Correspondência sem diferenciação entre maiúsculas e minúsculasCase-Insensitive Matching

A opção IgnoreCase ou a opção embutida i fornece correspondência sem diferenciação entre maiúsculas e minúsculas.The IgnoreCase option, or the i inline option, provides case-insensitive matching. Por padrão, são usadas as convenções de diferenciação entre maiúsculas e minúsculas da cultura atual.By default, the casing conventions of the current culture are used.

O exemplo a seguir define um padrão de expressão regular, \bthe\w*\b, que corresponde a todas as palavras que começam com “the”.The following example defines a regular expression pattern, \bthe\w*\b, that matches all words starting with "the". Como a primeira chamada para o método Match usa a comparação que diferencia maiúsculas de minúsculas padrão, a saída indica que a cadeia de caracteres "The", que inicia a frase, não é combinada.Because the first call to the Match method uses the default case-sensitive comparison, the output indicates that the string "The" that begins the sentence is not matched. Ela é combinada quando o método Match é chamado com opções definidas para IgnoreCase.It is matched when the Match method is called with options set to IgnoreCase.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\bthe\w*\b";
      string input = "The man then told them about that event.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);

      Console.WriteLine();
      foreach (Match match in Regex.Matches(input, pattern, 
                                            RegexOptions.IgnoreCase))
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);
   }
}
// The example displays the following output:
//       Found then at index 8.
//       Found them at index 18.
//       
//       Found The at index 0.
//       Found then at index 8.
//       Found them at index 18.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\bthe\w*\b"
      Dim input As String = "The man then told them about that event."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
      Next
      Console.WriteLine()
      For Each match As Match In Regex.Matches(input, pattern, _
                                               RegexOptions.IgnoreCase)
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Found then at index 8.
'       Found them at index 18.
'       
'       Found The at index 0.
'       Found then at index 8.
'       Found them at index 18.

O exemplo a seguir modifica o padrão da expressão regular do exemplo anterior para usar opções embutidas, em vez do parâmetro options para fornecer comparação de diferenciação entre maiúsculas e minúsculas.The following example modifies the regular expression pattern from the previous example to use inline options instead of the options parameter to provide case-insensitive comparison. O primeiro padrão define a opção que não diferencia maiúsculas de minúsculas em um constructo de agrupamento que se aplica apenas à letra “t” na cadeia de caracteres “the”.The first pattern defines the case-insensitive option in a grouping construct that applies only to the letter "t" in the string "the". Como o constructo da opção ocorre no início do padrão, o segundo padrão aplica a opção que não diferencia maiúsculas de minúsculas a toda a expressão regular.Because the option construct occurs at the beginning of the pattern, the second pattern applies the case-insensitive option to the entire regular expression.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(?i:t)he\w*\b";
      string input = "The man then told them about that event.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);

      Console.WriteLine();
      pattern = @"(?i)\bthe\w*\b";
      foreach (Match match in Regex.Matches(input, pattern, 
                                            RegexOptions.IgnoreCase))
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);
   }
}
// The example displays the following output:
//       Found The at index 0.
//       Found then at index 8.
//       Found them at index 18.
//       
//       Found The at index 0.
//       Found then at index 8.
//       Found them at index 18.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(?i:t)he\w*\b"
      Dim input As String = "The man then told them about that event."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
      Next
      Console.WriteLine()
      pattern = "(?i)\bthe\w*\b"
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Found The at index 0.
'       Found then at index 8.
'       Found them at index 18.
'       
'       Found The at index 0.
'       Found then at index 8.
'       Found them at index 18.

Voltar ao inícioBack to Top

Modo multilinhaMultiline Mode

A opção RegexOptions.Multiline ou a opção embutida m habilita o mecanismo de expressão regular para processar uma cadeia de caracteres de entrada que consiste em várias linhas.The RegexOptions.Multiline option, or the m inline option, enables the regular expression engine to handle an input string that consists of multiple lines. Ele altera a interpretação dos elementos de linguagem ^ e $ para que correspondem com o início e o fim de uma linha, em vez de o início e o fim da cadeia de caracteres de entrada.It changes the interpretation of the ^ and $ language elements so that they match the beginning and end of a line, instead of the beginning and end of the input string.

Por padrão, $ corresponde apenas com o final da cadeia de caracteres de entrada.By default, $ matches only the end of the input string. Se você especificar a opção RegexOptions.Multiline, ela corresponde com o caractere newline (\n) ou com o fim da cadeia de caracteres de entrada.If you specify the RegexOptions.Multiline option, it matches either the newline character (\n) or the end of the input string. Porém, não corresponde à combinação de caractere de retorno de carro/avanço de linha.It does not, however, match the carriage return/line feed character combination. Para uma correspondência bem-sucedida, use a subexpressão \r?$ em vez de apenas $.To successfully match them, use the subexpression \r?$ instead of just $.

O exemplo a seguir extrai nomes e pontuações de jogadores de boliche e os adiciona a uma coleção SortedList<TKey,TValue>, que os classifica em ordem decrescente.The following example extracts bowlers' names and scores and adds them to a SortedList<TKey,TValue> collection that sorts them in descending order. O método Matches é chamado duas vezes.The Matches method is called twice. Na primeira chamada do método, a expressão regular é ^(\w+)\s(\d+)$ e nenhuma opção é definida.In the first method call, the regular expression is ^(\w+)\s(\d+)$ and no options are set. Como a saída mostra, uma vez que o mecanismo de expressões regulares não pode corresponder ao padrão de entrada junto com o início e o fim da cadeia de caracteres de entrada, nenhuma correspondência é encontrada.As the output shows, because the regular expression engine cannot match the input pattern along with the beginning and end of the input string, no matches are found. Na segunda chamada do método, a expressão regular é alterada para ^(\w+)\s(\d+)\r?$ e as opções são definidas para RegexOptions.Multiline.In the second method call, the regular expression is changed to ^(\w+)\s(\d+)\r?$ and the options are set to RegexOptions.Multiline. Como a saída mostra, os nomes e pontuações são combinados com sucesso e as pontuações são exibidas em ordem decrescente.As the output shows, the names and scores are successfully matched, and the scores are displayed in descending order.

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      SortedList<int, string> scores = new SortedList<int, string>(new DescendingComparer<int>());
      
      string input = "Joe 164\n" + 
                     "Sam 208\n" + 
                     "Allison 211\n" + 
                     "Gwen 171\n"; 
      string pattern = @"^(\w+)\s(\d+)$";
      bool matched = false;
      
      Console.WriteLine("Without Multiline option:");
      foreach (Match match in Regex.Matches(input, pattern))
      {
         scores.Add(Int32.Parse(match.Groups[2].Value), (string) match.Groups[1].Value);
         matched = true;
      }
      if (! matched)
         Console.WriteLine("   No matches.");
      Console.WriteLine();

      // Redefine pattern to handle multiple lines.
      pattern = @"^(\w+)\s(\d+)\r*$";
      Console.WriteLine("With multiline option:");
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Multiline))
         scores.Add(Int32.Parse(match.Groups[2].Value), (string) match.Groups[1].Value);

      // List scores in descending order. 
      foreach (KeyValuePair<int, string> score in scores)
         Console.WriteLine("{0}: {1}", score.Value, score.Key);
   }
}

public class DescendingComparer<T> : IComparer<T>
{
   public int Compare(T x, T y)
   {
      return Comparer<T>.Default.Compare(x, y) * -1;       
   }
}
// The example displays the following output:
//   Without Multiline option:
//      No matches.
//   
//   With multiline option:
//   Allison: 211
//   Sam: 208
//   Gwen: 171
//   Joe: 164
Imports System.Collections.Generic
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim scores As New SortedList(Of Integer, String)(New DescendingComparer(Of Integer)())
      
      Dim input As String = "Joe 164" + vbCrLf + _
                            "Sam 208" + vbCrLf + _
                            "Allison 211" + vbCrLf + _
                            "Gwen 171" + vbCrLf
      Dim pattern As String = "^(\w+)\s(\d+)$"
      Dim matched As Boolean = False
      
      Console.WriteLine("Without Multiline option:")
      For Each match As Match In Regex.Matches(input, pattern)
         scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
         matched = True
      Next
      If Not matched Then Console.WriteLine("   No matches.")
      Console.WriteLine()

      ' Redefine pattern to handle multiple lines.
      pattern = "^(\w+)\s(\d+)\r*$"
      Console.WriteLine("With multiline option:")
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.Multiline)
         scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
      Next
      ' List scores in descending order. 
      For Each score As KeyValuePair(Of Integer, String) In scores
         Console.WriteLine("{0}: {1}", score.Value, score.Key)
      Next
   End Sub
End Module

Public Class DescendingComparer(Of T) : Implements IComparer(Of T)
   Public Function Compare(x As T, y As T) As Integer _
          Implements IComparer(Of T).Compare
      Return Comparer(Of T).Default.Compare(x, y) * -1       
   End Function
End Class
' The example displays the following output:
'    Without Multiline option:
'       No matches.
'    
'    With multiline option:
'    Allison: 211
'    Sam: 208
'    Gwen: 171
'    Joe: 164

O padrão de expressão regular ^(\w+)\s(\d+)\r*$ é definido conforme mostrado na tabela a seguir.The regular expression pattern ^(\w+)\s(\d+)\r*$ is defined as shown in the following table.

PadrãoPattern DescriçãoDescription
^ Começar no início da linha.Begin at the start of the line.
(\w+) Corresponde a um ou mais caracteres de palavra.Match one or more word characters. Este é o primeiro grupo de captura.This is the first capturing group.
\s Corresponde a um caractere de espaço em branco.Match a white-space character.
(\d+) Corresponde a um ou mais dígitos decimais.Match one or more decimal digits. Este é o segundo grupo de captura.This is the second capturing group.
\r? Corresponder a zero ou um caractere de retorno de carro.Match zero or one carriage return character.
$ Terminar no fim da linha.End at the end of the line.

O exemplo a seguir é equivalente ao anterior, exceto que ele usa a opção embutida (?m) para definir a opção de multilinhas.The following example is equivalent to the previous one, except that it uses the inline option (?m) to set the multiline option.

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      SortedList<int, string> scores = new SortedList<int, string>(new DescendingComparer<int>());
      
      string input = "Joe 164\n" +  
                     "Sam 208\n" +  
                     "Allison 211\n" +  
                     "Gwen 171\n"; 
      string pattern = @"(?m)^(\w+)\s(\d+)\r*$";

      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Multiline))
         scores.Add(Convert.ToInt32(match.Groups[2].Value), match.Groups[1].Value);

      // List scores in descending order. 
      foreach (KeyValuePair<int, string> score in scores)
         Console.WriteLine("{0}: {1}", score.Value, score.Key);
   }
}

public class DescendingComparer<T> : IComparer<T>
{
   public int Compare(T x, T y) 
   {
      return Comparer<T>.Default.Compare(x, y) * -1;       
   }
}
// The example displays the following output:
//    Allison: 211
//    Sam: 208
//    Gwen: 171
//    Joe: 164
Imports System.Collections.Generic
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim scores As New SortedList(Of Integer, String)(New DescendingComparer(Of Integer)())
      
      Dim input As String = "Joe 164" + vbCrLf + _
                            "Sam 208" + vbCrLf + _
                            "Allison 211" + vbCrLf + _
                            "Gwen 171" + vbCrLf
      Dim pattern As String = "(?m)^(\w+)\s(\d+)\r*$"

      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.Multiline)
         scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
      Next
      ' List scores in descending order. 
      For Each score As KeyValuePair(Of Integer, String) In scores
         Console.WriteLine("{0}: {1}", score.Value, score.Key)
      Next
   End Sub
End Module

Public Class DescendingComparer(Of T) : Implements IComparer(Of T)
   Public Function Compare(x As T, y As T) As Integer _
          Implements IComparer(Of T).Compare
      Return Comparer(Of T).Default.Compare(x, y) * -1       
   End Function
End Class
' The example displays the following output:
'    Allison: 211
'    Sam: 208
'    Gwen: 171
'    Joe: 164

Voltar ao inícioBack to Top

Modo de linha únicaSingle-line Mode

A opção RegexOptions.Singleline, ou a opção embutida s, faz o mecanismo de expressão regular tratar a cadeia de caracteres de entrada como se consistisse em uma única linha.The RegexOptions.Singleline option, or the s inline option, causes the regular expression engine to treat the input string as if it consists of a single line. Ele faz isso mudando o comportamento do elemento de linguagem de ponto (.) para que corresponda a todos os caracteres, em vez de corresponder a todo caractere exceto pelo newline \n ou \u000A.It does this by changing the behavior of the period (.) language element so that it matches every character, instead of matching every character except for the newline character \n or \u000A.

O exemplo a seguir ilustra como o comportamento do elemento de linguagem . muda quando se usa a opção RegexOptions.Singleline.The following example illustrates how the behavior of the . language element changes when you use the RegexOptions.Singleline option. A expressão regular ^.+ começa no início da cadeia de caracteres e corresponde a todos os caracteres.The regular expression ^.+ starts at the beginning of the string and matches every character. Por padrão, a correspondência termina no final da primeira linha; o padrão de expressão regular corresponde ao caractere de retorno de carro, \r ou \ u000D, mas não corresponde a \n.By default, the match ends at the end of the first line; the regular expression pattern matches the carriage return character, \r or \u000D, but it does not match \n. Como a opção RegexOptions.Singleline interpreta toda a cadeia de caracteres de entrada como uma única linha, ela corresponde a cada caractere na cadeia de caracteres de entrada, incluindo \n.Because the RegexOptions.Singleline option interprets the entire input string as a single line, it matches every character in the input string, including \n.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "^.+";
      string input = "This is one line and" + Environment.NewLine + "this is the second.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(Regex.Escape(match.Value));

      Console.WriteLine();
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Singleline))
         Console.WriteLine(Regex.Escape(match.Value));
   }
}
// The example displays the following output:
//       This\ is\ one\ line\ and\r
//       
//       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "^.+"
      Dim input As String = "This is one line and" + vbCrLf + "this is the second."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(Regex.Escape(match.Value))
      Next
      Console.WriteLine()
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.SingleLine)
         Console.WriteLine(Regex.Escape(match.Value))
      Next
   End Sub
End Module
' The example displays the following output:
'       This\ is\ one\ line\ and\r
'       
'       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.

O exemplo a seguir é equivalente ao anterior, exceto que ele usa a opção embutida (?s) para habilitar o modo de linha única.The following example is equivalent to the previous one, except that it uses the inline option (?s) to enable single-line mode.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {      
      string pattern = "(?s)^.+";
      string input = "This is one line and" + Environment.NewLine + "this is the second.";

      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(Regex.Escape(match.Value));
   }
}
// The example displays the following output:
//       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(?s)^.+"
      Dim input As String = "This is one line and" + vbCrLf + "this is the second."

      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(Regex.Escape(match.Value))
      Next
   End Sub
End Module
' The example displays the following output:
'       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.

Voltar ao inícioBack to Top

Apenas capturas explícitasExplicit Captures Only

Por padrão, grupos de capturas são definidos pelo uso de parênteses no padrão de expressão regular.By default, capturing groups are defined by the use of parentheses in the regular expression pattern. Grupos nomeados recebem um nome ou número pela opção de linguagem (?<nome>subexpressão), enquanto grupos não nomeados são acessíveis pelo índice.Named groups are assigned a name or number by the (?<name>subexpression) language option, whereas unnamed groups are accessible by index. No objeto GroupCollection, grupos não nomeados precedem grupos nomeados.In the GroupCollection object, unnamed groups precede named groups.

Constructos de agrupamento costumam ser usados apenas para aplicar quantificadores a vários elementos de linguagem; as subcadeias de caracteres capturadas não são de interesse.Grouping constructs are often used only to apply quantifiers to multiple language elements, and the captured substrings are of no interest. Por exemplo, se a seguinte expressão regular:For example, if the following regular expression:

\b\(?((\w+),?\s?)+[\.!?]\)?

for feita somente para extrair frases que terminem com um ponto, ponto de exclamação ou ponto de interrogação de um documento, apenas a frase resultante (representada pelo objeto Match) é de interesse.is intended only to extract sentences that end with a period, exclamation point, or question mark from a document, only the resulting sentence (which is represented by the Match object) is of interest. As palavras individuais na coleção não são.The individual words in the collection are not.

Capturar grupos que não serão usados posteriormente pode ser caro, pois o mecanismo de expressão regular precisa preencher os objetos de coleção GroupCollection e CaptureCollection.Capturing groups that are not subsequently used can be expensive, because the regular expression engine must populate both the GroupCollection and CaptureCollection collection objects. Como alternativa, você pode usar a opção RegexOptions.ExplicitCapture ou a opção embutida n para especificar que apenas as capturas válidas são explicitamente nomeadas ou grupos numerados que são projetados pelo constructo (?<nome> subexpressão).As an alternative, you can use either the RegexOptions.ExplicitCapture option or the n inline option to specify that the only valid captures are explicitly named or numbered groups that are designated by the (?<name> subexpression) construct.

O exemplo a seguir exibe informações sobre as correspondências retornadas pelo padrão de expressão regular \b\(?((\w+),?\s?)+[\.!?]\)? quando o método Match é chamado com e sem a opção RegexOptions.ExplicitCapture.The following example displays information about the matches returned by the \b\(?((\w+),?\s?)+[\.!?]\)? regular expression pattern when the Match method is called with and without the RegexOptions.ExplicitCapture option. Como mostra a saída da chamada do primeiro método, o mecanismo de expressão regular preenche totalmente os objetos da coleção GroupCollection e CaptureCollection com informações sobre subcadeias de caracteres capturadas.As the output from the first method call shows, the regular expression engine fully populates the GroupCollection and CaptureCollection collection objects with information about captured substrings. Como o segundo método é chamado com options definido para RegexOptions.ExplicitCapture, ele não captura informações sobre grupos.Because the second method is called with options set to RegexOptions.ExplicitCapture, it does not capture information on groups.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is the first sentence. Is it the beginning " + 
                     "of a literary masterpiece? I think not. Instead, " + 
                     "it is a nonsensical paragraph.";
      string pattern = @"\b\(?((?>\w+),?\s?)+[\.!?]\)?";
      Console.WriteLine("With implicit captures:");
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine("The match: {0}", match.Value);
         int groupCtr = 0;
         foreach (Group group in match.Groups)
         {
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
            groupCtr++;
            int captureCtr = 0;
            foreach (Capture capture in group.Captures)
            {
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value);
               captureCtr++;
            }
         }
      }
      Console.WriteLine();
      Console.WriteLine("With explicit captures only:");
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.ExplicitCapture))
      {
         Console.WriteLine("The match: {0}", match.Value);
         int groupCtr = 0;
         foreach (Group group in match.Groups)
         {
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
            groupCtr++;
            int captureCtr = 0;
            foreach (Capture capture in group.Captures)
            {
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value);
               captureCtr++;
            }
         }
      }
   }
}
// The example displays the following output:
//    With implicit captures:
//    The match: This is the first sentence.
//       Group 0: This is the first sentence.
//          Capture 0: This is the first sentence.
//       Group 1: sentence
//          Capture 0: This
//          Capture 1: is
//          Capture 2: the
//          Capture 3: first
//          Capture 4: sentence
//       Group 2: sentence
//          Capture 0: This
//          Capture 1: is
//          Capture 2: the
//          Capture 3: first
//          Capture 4: sentence
//    The match: Is it the beginning of a literary masterpiece?
//       Group 0: Is it the beginning of a literary masterpiece?
//          Capture 0: Is it the beginning of a literary masterpiece?
//       Group 1: masterpiece
//          Capture 0: Is
//          Capture 1: it
//          Capture 2: the
//          Capture 3: beginning
//          Capture 4: of
//          Capture 5: a
//          Capture 6: literary
//          Capture 7: masterpiece
//       Group 2: masterpiece
//          Capture 0: Is
//          Capture 1: it
//          Capture 2: the
//          Capture 3: beginning
//          Capture 4: of
//          Capture 5: a
//          Capture 6: literary
//          Capture 7: masterpiece
//    The match: I think not.
//       Group 0: I think not.
//          Capture 0: I think not.
//       Group 1: not
//          Capture 0: I
//          Capture 1: think
//          Capture 2: not
//       Group 2: not
//          Capture 0: I
//          Capture 1: think
//          Capture 2: not
//    The match: Instead, it is a nonsensical paragraph.
//       Group 0: Instead, it is a nonsensical paragraph.
//          Capture 0: Instead, it is a nonsensical paragraph.
//       Group 1: paragraph
//          Capture 0: Instead,
//          Capture 1: it
//          Capture 2: is
//          Capture 3: a
//          Capture 4: nonsensical
//          Capture 5: paragraph
//       Group 2: paragraph
//          Capture 0: Instead
//          Capture 1: it
//          Capture 2: is
//          Capture 3: a
//          Capture 4: nonsensical
//          Capture 5: paragraph
//    
//    With explicit captures only:
//    The match: This is the first sentence.
//       Group 0: This is the first sentence.
//          Capture 0: This is the first sentence.
//    The match: Is it the beginning of a literary masterpiece?
//       Group 0: Is it the beginning of a literary masterpiece?
//          Capture 0: Is it the beginning of a literary masterpiece?
//    The match: I think not.
//       Group 0: I think not.
//          Capture 0: I think not.
//    The match: Instead, it is a nonsensical paragraph.
//       Group 0: Instead, it is a nonsensical paragraph.
//          Capture 0: Instead, it is a nonsensical paragraph.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is the first sentence. Is it the beginning " + _
                            "of a literary masterpiece? I think not. Instead, " + _
                            "it is a nonsensical paragraph."
      Dim pattern As String = "\b\(?((?>\w+),?\s?)+[\.!?]\)?"
      Console.WriteLine("With implicit captures:")
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("The match: {0}", match.Value)
         Dim groupCtr As Integer = 0
         For Each group As Group In match.Groups
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
            groupCtr += 1
            Dim captureCtr As Integer = 0
            For Each capture As Capture In group.Captures
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value)
               captureCtr += 1
            Next
         Next
      Next
      Console.WriteLine()
      Console.WriteLine("With explicit captures only:")
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.ExplicitCapture)
         Console.WriteLine("The match: {0}", match.Value)
         Dim groupCtr As Integer = 0
         For Each group As Group In match.Groups
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
            groupCtr += 1
            Dim captureCtr As Integer = 0
            For Each capture As Capture In group.Captures
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value)
               captureCtr += 1
            Next
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'    With implicit captures:
'    The match: This is the first sentence.
'       Group 0: This is the first sentence.
'          Capture 0: This is the first sentence.
'       Group 1: sentence
'          Capture 0: This
'          Capture 1: is
'          Capture 2: the
'          Capture 3: first
'          Capture 4: sentence
'       Group 2: sentence
'          Capture 0: This
'          Capture 1: is
'          Capture 2: the
'          Capture 3: first
'          Capture 4: sentence
'    The match: Is it the beginning of a literary masterpiece?
'       Group 0: Is it the beginning of a literary masterpiece?
'          Capture 0: Is it the beginning of a literary masterpiece?
'       Group 1: masterpiece
'          Capture 0: Is
'          Capture 1: it
'          Capture 2: the
'          Capture 3: beginning
'          Capture 4: of
'          Capture 5: a
'          Capture 6: literary
'          Capture 7: masterpiece
'       Group 2: masterpiece
'          Capture 0: Is
'          Capture 1: it
'          Capture 2: the
'          Capture 3: beginning
'          Capture 4: of
'          Capture 5: a
'          Capture 6: literary
'          Capture 7: masterpiece
'    The match: I think not.
'       Group 0: I think not.
'          Capture 0: I think not.
'       Group 1: not
'          Capture 0: I
'          Capture 1: think
'          Capture 2: not
'       Group 2: not
'          Capture 0: I
'          Capture 1: think
'          Capture 2: not
'    The match: Instead, it is a nonsensical paragraph.
'       Group 0: Instead, it is a nonsensical paragraph.
'          Capture 0: Instead, it is a nonsensical paragraph.
'       Group 1: paragraph
'          Capture 0: Instead,
'          Capture 1: it
'          Capture 2: is
'          Capture 3: a
'          Capture 4: nonsensical
'          Capture 5: paragraph
'       Group 2: paragraph
'          Capture 0: Instead
'          Capture 1: it
'          Capture 2: is
'          Capture 3: a
'          Capture 4: nonsensical
'          Capture 5: paragraph
'    
'    With explicit captures only:
'    The match: This is the first sentence.
'       Group 0: This is the first sentence.
'          Capture 0: This is the first sentence.
'    The match: Is it the beginning of a literary masterpiece?
'       Group 0: Is it the beginning of a literary masterpiece?
'          Capture 0: Is it the beginning of a literary masterpiece?
'    The match: I think not.
'       Group 0: I think not.
'          Capture 0: I think not.
'    The match: Instead, it is a nonsensical paragraph.
'       Group 0: Instead, it is a nonsensical paragraph.
'          Capture 0: Instead, it is a nonsensical paragraph.

O padrão de expressão regular\b\(?((?>\w+),?\s?)+[\.!?]\)? é definido como mostra a tabela a seguir.The regular expression pattern\b\(?((?>\w+),?\s?)+[\.!?]\)? is defined as shown in the following table.

PadrãoPattern DescriçãoDescription
\b Começar em um limite de palavra.Begin at a word boundary.
\(? Corresponder zero ou uma ocorrência do parêntese de abertura (“(“).Match zero or one occurrences of the opening parenthesis ("(").
(?>\w+),? Corresponder um ou mais caracteres de palavra seguidos por zero ou uma vírgula.Match one or more word characters, followed by zero or one commas. Não retroceda ao corresponder caracteres de palavra.Do not backtrack when matching word characters.
\s? Corresponder a zero ou a um caractere de espaço em branco.Match zero or one white-space characters.
((\w+),?\s?)+ Corresponder a combinação de um ou mais caracteres de palavra, zero ou mais vírgulas e zero ou um caractere de espaço em branco uma ou mais vezes.Match the combination of one or more word characters, zero or one commas, and zero or one white-space characters one or more times.
[\.!?]\)? Corresponder qualquer um dos três símbolos de pontuação seguidos por zero ou um parêntese de fechamento (“)”).Match any of the three punctuation symbols, followed by zero or one closing parentheses (")").

Você também pode usar o elemento embutido (?n) para suprimir capturas automáticas.You can also use the (?n) inline element to suppress automatic captures. O exemplo a seguir modifica o padrão de expressão regular anterior para usar o elemento embutido (?n) em vez da opção RegexOptions.ExplicitCapture.The following example modifies the previous regular expression pattern to use the (?n) inline element instead of the RegexOptions.ExplicitCapture option.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is the first sentence. Is it the beginning " + 
                     "of a literary masterpiece? I think not. Instead, " + 
                     "it is a nonsensical paragraph.";
      string pattern = @"(?n)\b\(?((?>\w+),?\s?)+[\.!?]\)?";

      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine("The match: {0}", match.Value);
         int groupCtr = 0;
         foreach (Group group in match.Groups)
         {
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
            groupCtr++;
            int captureCtr = 0;
            foreach (Capture capture in group.Captures)
            {
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value);
               captureCtr++;
            }
         }
      }
   }
}
// The example displays the following output:
//       The match: This is the first sentence.
//          Group 0: This is the first sentence.
//             Capture 0: This is the first sentence.
//       The match: Is it the beginning of a literary masterpiece?
//          Group 0: Is it the beginning of a literary masterpiece?
//             Capture 0: Is it the beginning of a literary masterpiece?
//       The match: I think not.
//          Group 0: I think not.
//             Capture 0: I think not.
//       The match: Instead, it is a nonsensical paragraph.
//          Group 0: Instead, it is a nonsensical paragraph.
//             Capture 0: Instead, it is a nonsensical paragraph.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is the first sentence. Is it the beginning " + _
                            "of a literary masterpiece? I think not. Instead, " + _
                            "it is a nonsensical paragraph."
      Dim pattern As String = "(?n)\b\(?((?>\w+),?\s?)+[\.!?]\)?"

      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("The match: {0}", match.Value)
         Dim groupCtr As Integer = 0
         For Each group As Group In match.Groups
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
            groupCtr += 1
            Dim captureCtr As Integer = 0
            For Each capture As Capture In group.Captures
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value)
               captureCtr += 1
            Next
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'       The match: This is the first sentence.
'          Group 0: This is the first sentence.
'             Capture 0: This is the first sentence.
'       The match: Is it the beginning of a literary masterpiece?
'          Group 0: Is it the beginning of a literary masterpiece?
'             Capture 0: Is it the beginning of a literary masterpiece?
'       The match: I think not.
'          Group 0: I think not.
'             Capture 0: I think not.
'       The match: Instead, it is a nonsensical paragraph.
'          Group 0: Instead, it is a nonsensical paragraph.
'             Capture 0: Instead, it is a nonsensical paragraph.

Por fim, é possível usar o elemento do grupo embutido (?n:) para suprimir capturas automáticas grupo a grupo.Finally, you can use the inline group element (?n:) to suppress automatic captures on a group-by-group basis. O exemplo a seguir modifica o padrão anterior para suprimir capturas sem nome no grupo externo, ((?>\w+),?\s?).The following example modifies the previous pattern to suppress unnamed captures in the outer group, ((?>\w+),?\s?). Observe que isso também suprime capturas sem nome no grupo interno.Note that this suppresses unnamed captures in the inner group as well.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is the first sentence. Is it the beginning " + 
                     "of a literary masterpiece? I think not. Instead, " + 
                     "it is a nonsensical paragraph.";
      string pattern = @"\b\(?(?n:(?>\w+),?\s?)+[\.!?]\)?";

      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine("The match: {0}", match.Value);
         int groupCtr = 0;
         foreach (Group group in match.Groups)
         {
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
            groupCtr++;
            int captureCtr = 0;
            foreach (Capture capture in group.Captures)
            {
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value);
               captureCtr++;
            }
         }
      }
   }
}
// The example displays the following output:
//       The match: This is the first sentence.
//          Group 0: This is the first sentence.
//             Capture 0: This is the first sentence.
//       The match: Is it the beginning of a literary masterpiece?
//          Group 0: Is it the beginning of a literary masterpiece?
//             Capture 0: Is it the beginning of a literary masterpiece?
//       The match: I think not.
//          Group 0: I think not.
//             Capture 0: I think not.
//       The match: Instead, it is a nonsensical paragraph.
//          Group 0: Instead, it is a nonsensical paragraph.
//             Capture 0: Instead, it is a nonsensical paragraph.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is the first sentence. Is it the beginning " + _
                            "of a literary masterpiece? I think not. Instead, " + _
                            "it is a nonsensical paragraph."
      Dim pattern As String = "\b\(?(?n:(?>\w+),?\s?)+[\.!?]\)?"

      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("The match: {0}", match.Value)
         Dim groupCtr As Integer = 0
         For Each group As Group In match.Groups
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
            groupCtr += 1
            Dim captureCtr As Integer = 0
            For Each capture As Capture In group.Captures
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value)
               captureCtr += 1
            Next
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'       The match: This is the first sentence.
'          Group 0: This is the first sentence.
'             Capture 0: This is the first sentence.
'       The match: Is it the beginning of a literary masterpiece?
'          Group 0: Is it the beginning of a literary masterpiece?
'             Capture 0: Is it the beginning of a literary masterpiece?
'       The match: I think not.
'          Group 0: I think not.
'             Capture 0: I think not.
'       The match: Instead, it is a nonsensical paragraph.
'          Group 0: Instead, it is a nonsensical paragraph.
'             Capture 0: Instead, it is a nonsensical paragraph.

Voltar ao inícioBack to Top

Expressões regulares compiladasCompiled Regular Expressions

Por padrão, as expressões regulares no .NET são interpretadas.By default, regular expressions in .NET are interpreted. Quando um objeto Regex é instanciado ou um método Regex estático é chamado, o padrão de expressão regular é analisado em um conjunto de opcodes personalizados, e um interpretador usa esses opcodes para executar a expressão regular.When a Regex object is instantiated or a static Regex method is called, the regular expression pattern is parsed into a set of custom opcodes, and an interpreter uses these opcodes to run the regular expression. Isso envolve uma troca: o custo de inicializar o mecanismo de expressões regulares é minimizado com prejuízo do desempenho do tempo de execução.This involves a tradeoff: The cost of initializing the regular expression engine is minimized at the expense of run-time performance.

Você pode usar expressões regulares compiladas, em vez de interpretadas, usando a opção RegexOptions.Compiled.You can use compiled instead of interpreted regular expressions by using the RegexOptions.Compiled option. Neste caso, quando um padrão é enviado ao mecanismo de expressões regulares, ele é analisado em um subconjunto de opcodes e convertido para a MSIL (linguagem intermediária da Microsoft), que pode ser enviada diretamente ao Common Language Runtime.In this case, when a pattern is passed to the regular expression engine, it is parsed into a set of opcodes and then converted to Microsoft intermediate language (MSIL), which can be passed directly to the common language runtime. Expressões regulares compiladas maximizam o desempenho do tempo de execução às custas do tempo de inicialização.Compiled regular expressions maximize run-time performance at the expense of initialization time.

Observação

Uma expressão regular só pode ser compilada fornecendo o valor RegexOptions.Compiled ao parâmetro options de um construtor de classe Regex ou um método de correspondência padrão estático.A regular expression can be compiled only by supplying the RegexOptions.Compiled value to the options parameter of a Regex class constructor or a static pattern-matching method. Não está disponível como uma opção embutida.It is not available as an inline option.

É possível usar expressões regulares compiladas em chamadas para expressões regulares estáticas e de instância.You can use compiled regular expressions in calls to both static and instance regular expressions. Em expressões regulares estáticas, a opção RegexOptions.Compiled é enviada ao parâmetro options do método de correspondência padrão de expressão regular.In static regular expressions, the RegexOptions.Compiled option is passed to the options parameter of the regular expression pattern-matching method. Em expressões regulares de instância, é enviado ao parâmetro options do construtor de classe Regex.In instance regular expressions, it is passed to the options parameter of the Regex class constructor. Em ambos os casos, resulta em melhoria de desempenho.In both cases, it results in enhanced performance.

Porém, essa melhoria de desempenho ocorre apenas sob as seguintes condições:However, this improvement in performance occurs only under the following conditions:

  • É usado um objeto Regex que representa uma expressão regular em particular, em várias chamadas para métodos de correspondência padrão de expressão regular.A Regex object that represents a particular regular expression is used in multiple calls to regular expression pattern-matching methods.

  • O objeto Regex não pode sair do escopo, então pode ser reutilizado.The Regex object is not allowed to go out of scope, so it can be reused.

  • Uma expressão regular estática é usada em várias chamadas para métodos de correspondência padrão de expressão regular.A static regular expression is used in multiple calls to regular expression pattern-matching methods. (A melhoria de desempenho é possível porque as expressões regulares usadas em chamadas de método estático são armazenadas em cache pelo mecanismo de expressões regulares.)(The performance improvement is possible because regular expressions used in static method calls are cached by the regular expression engine.)

Observação

A opção RegexOptions.Compiled não está relacionada ao método Regex.CompileToAssembly, que cria um assembly de uso especial contendo expressões regulares compiladas predefinidas.The RegexOptions.Compiled option is unrelated to the Regex.CompileToAssembly method, which creates a special-purpose assembly that contains predefined compiled regular expressions.

Voltar ao inícioBack to Top

Ignorar espaço em brancoIgnore White Space

Por padrão, o espaço em branco em um padrão de expressão regular é significativo; ele força o mecanismo de expressões regulares para combinar um caractere de espaço em branco na cadeia de caracteres de entrada.By default, white space in a regular expression pattern is significant; it forces the regular expression engine to match a white-space character in the input string. Devido a isso, a expressão regular "\b\w+\s" e "\b\w+" são, de um modo geral, equivalentes.Because of this, the regular expression "\b\w+\s" and "\b\w+ " are roughly equivalent regular expressions. Além disso, quando a tecla de cerquilha (#) é encontrada em um padrão de expressão regular, ela é interpretada como um caractere literal a ser combinado.In addition, when the number sign (#) is encountered in a regular expression pattern, it is interpreted as a literal character to be matched.

A opção RegexOptions.IgnorePatternWhitespace ou a opção embutida x muda seu comportamento padrão da seguinte maneira:The RegexOptions.IgnorePatternWhitespace option, or the x inline option, changes this default behavior as follows:

  • É ignorado o espaço em branco sem escape no padrão de expressão regular.Unescaped white space in the regular expression pattern is ignored. Para fazer parte de um padrão de expressão regular, os caracteres de espaço em branco devem ser escapados (por exemplo, \s ou "\").To be part of a regular expression pattern, white-space characters must be escaped (for example, as \s or "\ ").

  • A tecla de cerquilha (#) é interpretada como o início de um comentário, em vez de um caractere literal.The number sign (#) is interpreted as the beginning of a comment, rather than as a literal character. Todo o texto no padrão de expressão regular do caractere # até o fim da cadeia de caracteres é interpretado como comentário.All text in the regular expression pattern from the # character to the end of the string is interpreted as a comment.

No entanto, nos casos a seguir, os caracteres de espaço em branco em uma expressão regular não serão ignorados, mesmo se você usar a opção RegexOptions.IgnorePatternWhitespace:However, in the following cases, white-space characters in a regular expression aren't ignored, even if you use the RegexOptions.IgnorePatternWhitespace option:

  • O espaço em branco dentro de uma classe de caractere sempre é interpretado literalmente.White space within a character class is always interpreted literally. Por exemplo, o padrão da expressão regular [ .,;:] corresponde a qualquer caractere de espaço em branco, ponto, vírgula, dois pontos ou ponto e vírgula único.For example, the regular expression pattern [ .,;:] matches any single white-space character, period, comma, semicolon, or colon.

  • O espaço em branco não é permitido dentro de um quantificador entre colchetes, como {n}, {n,} e {n,m}.White space isn't allowed within a bracketed quantifier, such as {n}, {n,}, and {n,m}. Por exemplo, o padrão de expressão regular \d{1, 3} falha ao corresponder quaisquer sequências de dígitos de um a três dígitos porque contém um caractere de espaço em branco.For example, the regular expression pattern \d{1, 3} fails to match any sequences of digits from one to three digits because it contains a white-space character.

  • Não é permitido espaço em branco dentro da sequência de caracteres que introduz um elemento de linguagem.White space isn't allowed within a character sequence that introduces a language element. Por exemplo:For example:

    • O elemento de linguagem (?:subexpressão) representa um grupo sem captura; a parte (?: do elemento não pode ter espaços inseridos.The language element (?:subexpression) represents a noncapturing group, and the (?: portion of the element can't have embedded spaces. O padrão (? :subexpressão) lança uma ArgumentException no tempo de execução porque o mecanismo de expressão regular não consegue analisar o padrão, e o padrão ( ?:subexpressão) falha em corresponder a subexpressão.The pattern (? :subexpression) throws an ArgumentException at run time because the regular expression engine can't parse the pattern, and the pattern ( ?:subexpression) fails to match subexpression.

    • O elemento de linguagem \p{name}, que representa uma categoria Unicode ou um bloco nomeado, não pode incluir espaços inseridos na parte \p{ do elemento.The language element \p{name}, which represents a Unicode category or named block, can't include embedded spaces in the \p{ portion of the element. Se você incluir um espaço em branco, o elemento lança uma ArgumentException no tempo de execução.If you do include a white space, the element throws an ArgumentException at run time.

Habilitar essa opção ajuda a simplificar expressões regulares que costumam ser difíceis de analisar e entender.Enabling this option helps simplify regular expressions that are often difficult to parse and to understand. Melhora a legibilidade e torna possível documentar uma expressão regular.It improves readability, and makes it possible to document a regular expression.

O exemplo a seguir define o padrão de expressão regular a seguir:The following example defines the following regular expression pattern:

\b \(? ( (?>\w+) ,?\s? )+ [\.!?] \)? # Matches an entire sentence.

Esse padrão é similar ao padrão definido na seção Apenas capturas explícitas, exceto por usar a opção RegexOptions.IgnorePatternWhitespace para ignorar espaço em branco de padrão.This pattern is similar to the pattern defined in the Explicit Captures Only section, except that it uses the RegexOptions.IgnorePatternWhitespace option to ignore pattern white space.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is the first sentence. Is it the beginning " + 
                     "of a literary masterpiece? I think not. Instead, " + 
                     "it is a nonsensical paragraph.";
      string pattern = @"\b \(? ( (?>\w+) ,?\s? )+ [\.!?] \)? # Matches an entire sentence.";

      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnorePatternWhitespace))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       This is the first sentence.
//       Is it the beginning of a literary masterpiece?
//       I think not.
//       Instead, it is a nonsensical paragraph.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is the first sentence. Is it the beginning " + _
                            "of a literary masterpiece? I think not. Instead, " + _
                            "it is a nonsensical paragraph."
      Dim pattern As String = "\b \(? ( (?>\w+) ,?\s? )+  [\.!?] \)? # Matches an entire sentence."
      
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnorePatternWhitespace)
         Console.WriteLine(match.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       This is the first sentence.
'       Is it the beginning of a literary masterpiece?
'       I think not.
'       Instead, it is a nonsensical paragraph.

O exemplo a seguir usa a opção embutida (?x) para ignorar o espaço em branco padrão.The following example uses the inline option (?x) to ignore pattern white space.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is the first sentence. Is it the beginning " + 
                     "of a literary masterpiece? I think not. Instead, " + 
                     "it is a nonsensical paragraph.";
      string pattern = @"(?x)\b \(? ( (?>\w+) ,?\s? )+  [\.!?] \)? # Matches an entire sentence.";

      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       This is the first sentence.
//       Is it the beginning of a literary masterpiece?
//       I think not.
//       Instead, it is a nonsensical paragraph.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is the first sentence. Is it the beginning " + _
                            "of a literary masterpiece? I think not. Instead, " + _
                            "it is a nonsensical paragraph."
      Dim pattern As String = "(?x)\b \(? ( (?>\w+) ,?\s? )+  [\.!?] \)? # Matches an entire sentence."
      
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       This is the first sentence.
'       Is it the beginning of a literary masterpiece?
'       I think not.
'       Instead, it is a nonsensical paragraph.

Voltar ao inícioBack to Top

Modo da direita para a esquerdaRight-to-Left Mode

Por padrão, o mecanismo de expressões regulares pesquisa da esquerda para a direita.By default, the regular expression engine searches from left to right. É possível reverter a direção de pesquisa usando a opção RegexOptions.RightToLeft.You can reverse the search direction by using the RegexOptions.RightToLeft option. A pesquisa inicia automaticamente na última posição de caractere da cadeia de caracteres.The search automatically begins at the last character position of the string. Para métodos de correspondência padrão que incluem um parâmetro de posição inicial, como Regex.Match(String, Int32), a posição inicial é o índice da posição do caractere mais à direita em que a pesquisa deve iniciar.For pattern-matching methods that include a starting position parameter, such as Regex.Match(String, Int32), the starting position is the index of the rightmost character position at which the search is to begin.

Observação

O modo de padrão da direita para a esquerda está disponível apenas fornecendo o valor RegexOptions.RightToLeft para o parâmetro options de um construtor de classe Regex ou o método de correspondência padrão estático.Right-to-left pattern mode is available only by supplying the RegexOptions.RightToLeft value to the options parameter of a Regex class constructor or static pattern-matching method. Não está disponível como uma opção embutida.It is not available as an inline option.

A opção RegexOptions.RightToLeft só muda a direção de pesquisa, ela não interpreta o padrão de expressão regular da direita para a esquerda.The RegexOptions.RightToLeft option changes the search direction only; it does not interpret the regular expression pattern from right to left. Por exemplo, a expressão regular \bb\w+\s corresponde palavras que começam com a letra “b” e são seguidas por um caractere de espaço em branco.For example, the regular expression \bb\w+\s matches words that begin with the letter "b" and are followed by a white-space character. No exemplo a seguir, a cadeia de caracteres de entrada consiste em três palavras que incluem um ou mais caracteres “b”.In the following example, the input string consists of three words that include one or more "b" characters. A primeira palavra começa com “b”, a segunda termina com “b” e a terceira inclui dois caracteres “b” no meio da palavra.The first word begins with "b", the second ends with "b", and the third includes two "b" characters in the middle of the word. Como a saída do exemplo mostra, apenas a primeira palavra corresponde ao padrão da expressão regular.As the output from the example shows, only the first word matches the regular expression pattern.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\bb\w+\s";
      string input = "builder rob rabble";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.RightToLeft))
         Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);     
   }
}
// The example displays the following output:
//       'builder ' found at position 0.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\bb\w+\s"
      Dim input As String = "builder rob rabble"
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.RightToLeft)
         Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)     
      Next
   End Sub
End Module
' The example displays the following output:
'       'builder ' found at position 0.

Observe também que a asserção lookahead (o elemento de linguagem (?=subexpression)) e a asserção lookbehind (o elemento de linguagem (?<=subexpression)) não mudam de direção.Also note that the lookahead assertion (the (?=subexpression) language element) and the lookbehind assertion (the (?<=subexpression) language element) do not change direction. As asserções lookahead buscam à direita; as asserções lookbehind buscam à esquerda.The lookahead assertions look to the right; the lookbehind assertions look to the left. Por exemplo, a expressão regular (?<=\d{1,2}\s)\w+,?\s\d{4} usa a asserção lookbehind para testar uma data que antecede um nome de mês.For example, the regular expression (?<=\d{1,2}\s)\w+,?\s\d{4} uses the lookbehind assertion to test for a date that precedes a month name. A expressão regular corresponde ao mês e o ano.The regular expression then matches the month and the year. Saiba mais sobre as asserções lookahead e lookbehind em Constructos de agrupamento.For information on lookahead and lookbehind assertions, see Grouping Constructs.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "1 May 1917", "June 16, 2003" };
      string pattern = @"(?<=\d{1,2}\s)\w+,?\s\d{4}";
      
      foreach (string input in inputs)
      {
         Match match = Regex.Match(input, pattern, RegexOptions.RightToLeft);
         if (match.Success)
            Console.WriteLine("The date occurs in {0}.", match.Value);
         else
            Console.WriteLine("{0} does not match.", input);
      }
   }
}
// The example displays the following output:
//       The date occurs in May 1917.
//       June 16, 2003 does not match.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim inputs() As String = { "1 May 1917", "June 16, 2003" }
      Dim pattern As String = "(?<=\d{1,2}\s)\w+,?\s\d{4}"
      
      For Each input As String In inputs
         Dim match As Match = Regex.Match(input, pattern, RegexOptions.RightToLeft)
         If match.Success Then
            Console.WriteLine("The date occurs in {0}.", match.Value)
         Else
            Console.WriteLine("{0} does not match.", input)
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'       The date occurs in May 1917.
'       June 16, 2003 does not match.

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
(?<=\d{1,2}\s) O início da correspondência deve ser antecedido por um ou dois dígitos decimais seguidos por um espaço.The beginning of the match must be preceded by one or two decimal digits followed by a space.
\w+ Corresponde a um ou mais caracteres de palavra.Match one or more word characters.
,? Corresponder a zero ou um caractere de vírgula.Match zero or one comma characters.
\s Corresponde a um caractere de espaço em branco.Match a white-space character.
\d{4} Corresponder a quatro dígitos decimais.Match four decimal digits.

Voltar ao inícioBack to Top

Comportamento de correspondência de ECMAScriptECMAScript Matching Behavior

Por padrão, o mecanismo de expressões regulares usa comportamento canônico ao corresponder um padrão de expressão regular a um texto de entrada.By default, the regular expression engine uses canonical behavior when matching a regular expression pattern to input text. Porém, é possível instruir o mecanismo de expressão regular a usar o comportamento de correspondência ECMAScript especificando a opção RegexOptions.ECMAScript.However, you can instruct the regular expression engine to use ECMAScript matching behavior by specifying the RegexOptions.ECMAScript option.

Observação

O comportamento compatível com ECMAScript está disponível apenas fornecendo o valor RegexOptions.ECMAScript para o parâmetro options de um construtor de classe Regex ou método de correspondência padrão estático.ECMAScript-compliant behavior is available only by supplying the RegexOptions.ECMAScript value to the options parameter of a Regex class constructor or static pattern-matching method. Não está disponível como uma opção embutida.It is not available as an inline option.

A opção RegexOptions.ECMAScript só pode ser combinada com as opções RegexOptions.IgnoreCase e RegexOptions.Multiline.The RegexOptions.ECMAScript option can be combined only with the RegexOptions.IgnoreCase and RegexOptions.Multiline options. O uso de qualquer outra opção em uma expressão regular resulta em ArgumentOutOfRangeException.The use of any other option in a regular expression results in an ArgumentOutOfRangeException.

O comportamento das expressões regulares ECMAScript e canônicas difere em três áreas: sintaxe da classe de caractere, grupos de captura autorreferidos e interpretação octal versus de referência inversa.The behavior of ECMAScript and canonical regular expressions differs in three areas: character class syntax, self-referencing capturing groups, and octal versus backreference interpretation.

  • Sintaxe da classe de caractere.Character class syntax. Como as expressões regulares canônicas dão suporte a Unicode e o ECMAScrip não, as classes de caractere no ECMAScrip têm uma sintaxe mais limitada e alguns elementos de linguagem da classe de caractere têm um significado diferente.Because canonical regular expressions support Unicode whereas ECMAScript does not, character classes in ECMAScript have a more limited syntax, and some character class language elements have a different meaning. Por exemplo, o ECMAScript não oferece suporte a elementos de linguagem como a categoria Unicode ou elementos de bloco \p e \P.For example, ECMAScript does not support language elements such as the Unicode category or block elements \p and \P. De modo similar, o elemento \w, que corresponde um caractere de palavra, é equivalente à classe de caractere [a-zA-Z_0-9] ao usar ECMAScript e [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}] ao usar comportamento canônico.Similarly, the \w element, which matches a word character, is equivalent to the [a-zA-Z_0-9] character class when using ECMAScript and [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}] when using canonical behavior. Para saber mais, confira Classes de caracteres.For more information, see Character Classes.

    O exemplo a seguir ilustra a diferença entre correspondência padrão ECMAScript e canônica.The following example illustrates the difference between canonical and ECMAScript pattern matching. Define uma expressão regular, \b(\w+\s*)+, que combina palavras seguidas por caracteres de espaço em branco.It defines a regular expression, \b(\w+\s*)+, that matches words followed by white-space characters. A entrada consiste em duas cadeias de caracteres, uma que usa o conjunto de caracteres latinos e outra que usa o conjunto de caracteres cirílicos.The input consists of two strings, one that uses the Latin character set and the other that uses the Cyrillic character set. Como a saída mostra, a chamada para o método Regex.IsMatch(String, String, RegexOptions) que usa correspondência ECMAScript falha ao combinar as palavras cirílicas, enquanto a chamada de método que usa correspondência canônica não corresponde essas palavras.As the output shows, the call to the Regex.IsMatch(String, String, RegexOptions) method that uses ECMAScript matching fails to match the Cyrillic words, whereas the method call that uses canonical matching does match these words.

    using System;
    using System.Text.RegularExpressions;
    
    public class Example
    {
       public static void Main()
       {
          string[] values = { "целый мир", "the whole world" };
          string pattern = @"\b(\w+\s*)+";
          foreach (var value in values)
          {
             Console.Write("Canonical matching: ");
             if (Regex.IsMatch(value, pattern))
                Console.WriteLine("'{0}' matches the pattern.", value);
             else
                Console.WriteLine("{0} does not match the pattern.", value);
             
             Console.Write("ECMAScript matching: ");
             if (Regex.IsMatch(value, pattern, RegexOptions.ECMAScript))
                Console.WriteLine("'{0}' matches the pattern.", value);
             else
                Console.WriteLine("{0} does not match the pattern.", value);
             Console.WriteLine();
          }
       }
    }
    // The example displays the following output:
    //       Canonical matching: 'целый мир' matches the pattern.
    //       ECMAScript matching: целый мир does not match the pattern.
    //       
    //       Canonical matching: 'the whole world' matches the pattern.
    //       ECMAScript matching: 'the whole world' matches the pattern.
    
    Imports System.Text.RegularExpressions
    
    Module Example
       Public Sub Main()
          Dim values() As String = { "целый мир", "the whole world" }
          Dim pattern As String = "\b(\w+\s*)+"
          For Each value In values
             Console.Write("Canonical matching: ")
             If Regex.IsMatch(value, pattern)
                Console.WriteLine("'{0}' matches the pattern.", value)
             Else
                Console.WriteLine("{0} does not match the pattern.", value)
             End If
             
             Console.Write("ECMAScript matching: ")
             If Regex.IsMatch(value, pattern, RegexOptions.ECMAScript)
                Console.WriteLine("'{0}' matches the pattern.", value)
             Else
                Console.WriteLine("{0} does not match the pattern.", value)
             End If
             Console.WriteLine()
          Next
       End Sub
    End Module
    ' The example displays the following output:
    '       Canonical matching: 'целый мир' matches the pattern.
    '       ECMAScript matching: целый мир does not match the pattern.
    '       
    '       Canonical matching: 'the whole world' matches the pattern.
    '       ECMAScript matching: 'the whole world' matches the pattern.
    
  • Grupos de capturas com autorreferência.Self-referencing capturing groups. Uma classe de captura de expressão regular com uma referência inversa para si mesma deve ser atualizada com cada iteração de captura.A regular expression capture class with a backreference to itself must be updated with each capture iteration. Como o exemplo a seguir mostra, esse recurso habilita a expressão regular ((a+)(\1) ?)+ para corresponder a cadeia de caracteres de entrada “ aa aaaa aaaaaa ” ao usar ECMAScript, mas não ao usar correspondência canônica.As the following example shows, this feature enables the regular expression ((a+)(\1) ?)+ to match the input string " aa aaaa aaaaaa " when using ECMAScript, but not when using canonical matching.

    using System;
    using System.Text.RegularExpressions;
    
    public class Example
    {
       static string pattern;
       
       public static void Main()
       {
          string input = "aa aaaa aaaaaa "; 
          pattern = @"((a+)(\1) ?)+";
          
          // Match input using canonical matching.
          AnalyzeMatch(Regex.Match(input, pattern));
          
          // Match input using ECMAScript.
          AnalyzeMatch(Regex.Match(input, pattern, RegexOptions.ECMAScript));
       }   
       
       private static void AnalyzeMatch(Match m)
       {
          if (m.Success)
          {
             Console.WriteLine("'{0}' matches {1} at position {2}.",  
                               pattern, m.Value, m.Index);
             int grpCtr = 0;
             foreach (Group grp in m.Groups)
             {
                Console.WriteLine("   {0}: '{1}'", grpCtr, grp.Value);
                grpCtr++;
                int capCtr = 0;
                foreach (Capture cap in grp.Captures)
                {
                   Console.WriteLine("      {0}: '{1}'", capCtr, cap.Value);
                   capCtr++;
                }
             }
          }
          else
          {
             Console.WriteLine("No match found.");
          }   
          Console.WriteLine();
       }
    }
    // The example displays the following output:
    //    No match found.
    //    
    //    '((a+)(\1) ?)+' matches aa aaaa aaaaaa  at position 0.
    //       0: 'aa aaaa aaaaaa '
    //          0: 'aa aaaa aaaaaa '
    //       1: 'aaaaaa '
    //          0: 'aa '
    //          1: 'aaaa '
    //          2: 'aaaaaa '
    //       2: 'aa'
    //          0: 'aa'
    //          1: 'aa'
    //          2: 'aa'
    //       3: 'aaaa '
    //          0: ''
    //          1: 'aa '
    //          2: 'aaaa '
    
    Imports System.Text.RegularExpressions
    
    Module Example
       Dim pattern As String
       
       Public Sub Main()
          Dim input As String = "aa aaaa aaaaaa " 
          pattern = "((a+)(\1) ?)+"
          
          ' Match input using canonical matching.
          AnalyzeMatch(Regex.Match(input, pattern))
          
          ' Match input using ECMAScript.
          AnalyzeMatch(Regex.Match(input, pattern, RegexOptions.ECMAScript))
       End Sub   
       
       Private Sub AnalyzeMatch(m As Match)
          If m.Success
             Console.WriteLine("'{0}' matches {1} at position {2}.", _ 
                               pattern, m.Value, m.Index)
             Dim grpCtr As Integer = 0
             For Each grp As Group In m.Groups
                Console.WriteLine("   {0}: '{1}'", grpCtr, grp.Value)
                grpCtr += 1
                Dim capCtr As Integer = 0
                For Each cap As Capture In grp.Captures
                   Console.WriteLine("      {0}: '{1}'", capCtr, cap.Value)
                   capCtr += 1
                Next
             Next
          Else
             Console.WriteLine("No match found.")
          End If   
          Console.WriteLine()
       End Sub
    End Module
    ' The example displays the following output:
    '    No match found.
    '    
    '    '((a+)(\1) ?)+' matches aa aaaa aaaaaa  at position 0.
    '       0: 'aa aaaa aaaaaa '
    '          0: 'aa aaaa aaaaaa '
    '       1: 'aaaaaa '
    '          0: 'aa '
    '          1: 'aaaa '
    '          2: 'aaaaaa '
    '       2: 'aa'
    '          0: 'aa'
    '          1: 'aa'
    '          2: 'aa'
    '       3: 'aaaa '
    '          0: ''
    '          1: 'aa '
    '          2: 'aaaa '
    

    A expressão regular é definida como mostrado na tabela a seguir.The regular expression is defined as shown in the following table.

    PadrãoPattern DescriçãoDescription
    (a+)(a+) Corresponda a letra "a" uma ou mais vezes.Match the letter "a" one or more times. Este é o segundo grupo de captura.This is the second capturing group.
    (\1)(\1) Corresponda a subcadeia de caracteres capturada pelo primeiro grupo de captura.Match the substring captured by the first capturing group. Este é o terceiro grupo de captura.This is the third capturing group.
    ?? Corresponda zero ou um caractere de espaço.Match zero or one space characters.
    ((a+)(\1) ?)+((a+)(\1) ?)+ Corresponda o padrão de um ou mais caracteres "a" seguidos por uma cadeia de caracteres que corresponda o primeiro grupo de capturas seguido por zero ou um caractere de espaço uma ou mais vezes.Match the pattern of one or more "a" characters followed by a string that matches the first capturing group followed by zero or one space characters one or more times. Este é o primeiro grupo de captura.This is the first capturing group.
  • Resolução de ambiguidades entre escapes octais e referências inversas.Resolution of ambiguities between octal escapes and backreferences. A tabela a seguir resume as diferenças na interpretação octal versus de referência inversa por expressões regulares canônicas e ECMAScript.The following table summarizes the differences in octal versus backreference interpretation by canonical and ECMAScript regular expressions.

    Expressão regularRegular expression Comportamento canônicoCanonical behavior Comportamento de ECMAScriptECMAScript behavior
    \0 seguido por 0 - 2 dígitos octais\0 followed by 0 to 2 octal digits Interprete como um octal.Interpret as an octal. Por exemplo, \044 é sempre interpretado como um valor octal e significa "$".For example, \044 is always interpreted as an octal value and means "$". Mesmo comportamento.Same behavior.
    \ seguido por um dígito de 1 a 9, seguido por nenhum dígito decimal adicional,\ followed by a digit from 1 to 9, followed by no additional decimal digits, Interprete como referência inversa.Interpret as a backreference. Por exemplo, \9 sempre significa referência inversa 9, mesmo que um nono grupo de capturas não exista.For example, \9 always means backreference 9, even if a ninth capturing group does not exist. Se o grupo de captura não existir, o analisador de expressão regular lança uma ArgumentException.If the capturing group does not exist, the regular expression parser throws an ArgumentException. Se existir um grupo de capturas de um único dígito decimal, faça referência inversa a esse dígito.If a single decimal digit capturing group exists, backreference to that digit. Caso contrário, interprete o valor como literal.Otherwise, interpret the value as a literal.
    \ seguido por um dígito de 1 a 9, seguido por dígitos decimais adicionais\ followed by a digit from 1 to 9, followed by additional decimal digits Interprete os dígitos como um valor decimal.Interpret the digits as a decimal value. Se o grupo de capturas existir, interprete a expressão como referência inversa.If that capturing group exists, interpret the expression as a backreference.

    Caso contrário, interprete os dígitos octais iniciais até o octal 377; ou seja, considere apenas 8 bits inferiores do valor.Otherwise, interpret the leading octal digits up to octal 377; that is, consider only the low 8 bits of the value. Interprete os dígitos restantes como literais.Interpret the remaining digits as literals. Por exemplo, na expressão \3000, se o grupo de capturas 300 existir, interprete como referência inversa 300; se o grupo de capturas 300 não existir, interprete como um octal 300 seguido por 0.For example, in the expression \3000, if capturing group 300 exists, interpret as backreference 300; if capturing group 300 does not exist, interpret as octal 300 followed by 0.
    Interprete como uma referência inversa convertendo todos os dígitos possíveis para um valor decimal que pode fazer referência a uma captura.Interpret as a backreference by converting as many digits as possible to a decimal value that can refer to a capture. Se nenhum dígito puder ser convertido, interprete como um octal usando os dígitos octais iniciais até o octal 377; interprete os dígitos restantes como literais.If no digits can be converted, interpret as an octal by using the leading octal digits up to octal 377; interpret the remaining digits as literals.

Voltar ao inícioBack to Top

Comparação usando a cultura invariávelComparison Using the Invariant Culture

Por padrão, quando o mecanismo de expressão regular realiza comparações sem diferenciar maiúsculas de minúsculas, ele usa as convenções de maiúsculas de minúsculas da cultura atual para determinar caracteres equivalentes em maiúsculas e minúsculas.By default, when the regular expression engine performs case-insensitive comparisons, it uses the casing conventions of the current culture to determine equivalent uppercase and lowercase characters.

Porém, esse comportamento é indesejável para alguns tipos de comparações, especialmente ao comparar a entrada do usuário com os nomes de recursos do sistema, como senhas, arquivos ou URLs.However, this behavior is undesirable for some types of comparisons, particularly when comparing user input to the names of system resources, such as passwords, files, or URLs. O exemplo a seguir ilustra esse cenário.The following example illustrates such as scenario. O código tem como objetivo bloquear o acesso a qualquer recurso cuja URL seja prefixada com FILE:// .The code is intended to block access to any resource whose URL is prefaced with FILE://. A expressão regular tenta uma correspondência sem diferenciar maiúsculas e minúsculas com a cadeia de caracteres usando a expressão regular $FILE://.The regular expression attempts a case-insensitive match with the string by using the regular expression $FILE://. Porém, quando a cultura do sistema atual é tr-TR (Turco-Turquia), "I" não é o equivalente maiúsculo de "i".However, when the current system culture is tr-TR (Turkish-Turkey), "I" is not the uppercase equivalent of "i". Como resultado, a chamada para o método Regex.IsMatch retorna false e o acesso ao arquivo é permitido.As a result, the call to the Regex.IsMatch method returns false, and access to the file is allowed.

CultureInfo defaultCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new CultureInfo("tr-TR");

string input = "file://c:/Documents.MyReport.doc";
string pattern = "FILE://";

Console.WriteLine("Culture-sensitive matching ({0} culture)...", 
                  Thread.CurrentThread.CurrentCulture.Name);
if (Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase))
   Console.WriteLine("URLs that access files are not allowed.");      
else
   Console.WriteLine("Access to {0} is allowed.", input);

Thread.CurrentThread.CurrentCulture = defaultCulture;
// The example displays the following output:
//       Culture-sensitive matching (tr-TR culture)...
//       Access to file://c:/Documents.MyReport.doc is allowed.
Dim defaultCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
Thread.CurrentThread.CurrentCulture = New CultureInfo("tr-TR")

Dim input As String = "file://c:/Documents.MyReport.doc"
Dim pattern As String = "$FILE://"

Console.WriteLine("Culture-sensitive matching ({0} culture)...", _
                  Thread.CurrentThread.CurrentCulture.Name)
If Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase) Then
   Console.WriteLine("URLs that access files are not allowed.")      
Else
   Console.WriteLine("Access to {0} is allowed.", input)
End If

Thread.CurrentThread.CurrentCulture = defaultCulture
' The example displays the following output:
'       Culture-sensitive matching (tr-TR culture)...
'       Access to file://c:/Documents.MyReport.doc is allowed.

Observação

Para obter mais informações sobre comparações de cadeias de caracteres que diferenciam maiúsculas de minúsculas e usam cultura invariável, consulte Práticas recomendadas para o uso de cadeias de caracteres.For more information about string comparisons that are case-sensitive and that use the invariant culture, see Best Practices for Using Strings.

Em vez de usar comparações que não diferenciam maiúsculas de minúsculas da cultura atual, é possível especificar a opção RegexOptions.CultureInvariant para ignorar diferenças culturais no idioma e usar as convenções da cultura invariável.Instead of using the case-insensitive comparisons of the current culture, you can specify the RegexOptions.CultureInvariant option to ignore cultural differences in language and to use the conventions of the invariant culture.

Observação

A comparação usando cultura invariável está disponível apenas fornecendo o valor RegexOptions.CultureInvariant para o parâmetro options de um construtor de classe Regex ou método de correspondência padrão estático.Comparison using the invariant culture is available only by supplying the RegexOptions.CultureInvariant value to the options parameter of a Regex class constructor or static pattern-matching method. Não está disponível como uma opção embutida.It is not available as an inline option.

O exemplo a seguir é idêntico ao anterior, exceto que o método estático Regex.IsMatch(String, String, RegexOptions) é chamado com opções que incluem RegexOptions.CultureInvariant.The following example is identical to the previous example, except that the static Regex.IsMatch(String, String, RegexOptions) method is called with options that include RegexOptions.CultureInvariant. Mesmo quando a cultura atual é definida como turco (Turquia), o mecanismo de expressões regulares consegue corresponder com sucesso “FILE” e “file” e bloquear o acesso ao recurso do arquivo.Even when the current culture is set to Turkish (Turkey), the regular expression engine is able to successfully match "FILE" and "file" and block access to the file resource.

CultureInfo defaultCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new CultureInfo("tr-TR");

string input = "file://c:/Documents.MyReport.doc";
string pattern = "FILE://";

Console.WriteLine("Culture-insensitive matching...");
if (Regex.IsMatch(input, pattern, 
                  RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)) 
   Console.WriteLine("URLs that access files are not allowed.");
else
   Console.WriteLine("Access to {0} is allowed.", input);

Thread.CurrentThread.CurrentCulture = defaultCulture;
// The example displays the following output:
//       Culture-insensitive matching...
//       URLs that access files are not allowed.
Dim defaultCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
Thread.CurrentThread.CurrentCulture = New CultureInfo("tr-TR")

Dim input As String = "file://c:/Documents.MyReport.doc"
Dim pattern As String = "$FILE://"

Console.WriteLine("Culture-insensitive matching...")
If Regex.IsMatch(input, pattern, _
               RegexOptions.IgnoreCase Or RegexOptions.CultureInvariant) Then
   Console.WriteLine("URLs that access files are not allowed.")      
Else
   Console.WriteLine("Access to {0} is allowed.", input)
End If
Thread.CurrentThread.CurrentCulture = defaultCulture
' The example displays the following output:
'        Culture-insensitive matching...
'        URLs that access files are not allowed.

Consulte tambémSee also