Construtores diversos em expressões regularesMiscellaneous Constructs in Regular Expressions

As expressões regulares em .NET incluem três constructos diversos de linguagem.Regular expressions in .NET include three miscellaneous language constructs. Um deles permite habilitar ou desabilitar opções específicas de correspondência no meio de um padrão de expressão regular.One lets you enable or disable particular matching options in the middle of a regular expression pattern. Os dois restantes permitem incluir comentários em uma expressão regular.The remaining two let you include comments in a regular expression.

Opções embutidasInline Options

É possível definir ou desabilitar opções específicas de correspondência de padrão para parte de uma expressão regular mediante uso da sintaxeYou can set or disable specific pattern matching options for part of a regular expression by using the syntax

(?imnsx-imnsx)

Você lista as opções que deseja habilitar após o ponto de interrogação e as opções que deseja desabilitar após o sinal de subtração.You list the options you want to enable after the question mark, and the options you want to disable after the minus sign. A tabela a seguir descreve cada opção.The following table describes each option. Para obter mais informações sobre cada opção, consulte Opções de expressões regulares.For more information about each option, see Regular Expression Options.

OpçãoOption DescriçãoDescription
i Correspondência sem diferenciação entre maiúsculas e minúsculas.Case-insensitive matching.
m Modo multilinha.Multiline mode.
n Apenas capturas explícitas.Explicit captures only. (Parênteses não funcionam como grupos de captura.)(Parentheses do not act as capturing groups.)
s Modo de linha única.Single-line mode.
x Ignorar espaço em branco sem escape e permitir comentários no modo x.Ignore unescaped white space, and allow x-mode comments.

Qualquer alteração nas opções de expressões regulares definida pelo constructo (?imnsx-imnsx) permanece em vigor até o fim do grupo delimitador.Any change in regular expression options defined by the (?imnsx-imnsx) construct remains in effect until the end of the enclosing group.

Observação

O constructo de agrupamento (?imnsx-imnsx:subexpression) oferece uma funcionalidade idêntica para uma subexpressão.The (?imnsx-imnsx:subexpression) grouping construct provides identical functionality for a subexpression. Para saber mais, confira Constructos de agrupamento.For more information, see Grouping Constructs.

O exemplo a seguir usa as opções i, n e x para desabilitar a diferenciação entre maiúsculas e minúsculas e habilitar e capturas explícitas, bem como ignorar o espaço em branco no padrão de expressão regular no meio de uma expressão regular.The following example uses the i, n, and x options to enable case insensitivity and explicit captures, and to ignore white space in the regular expression pattern in the middle of a regular expression.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern; 
      string input = "double dare double Double a Drooling dog The Dreaded Deep";
      
      pattern = @"\b(D\w+)\s(d\w+)\b";
      // Match pattern using default options.
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine(match.Value);
         if (match.Groups.Count > 1)
            for (int ctr = 1; ctr < match.Groups.Count; ctr++) 
               Console.WriteLine("   Group {0}: {1}", ctr, match.Groups[ctr].Value);
      }
      Console.WriteLine();
      
      // Change regular expression pattern to include options.
      pattern = @"\b(D\w+)(?ixn) \s (d\w+) \b";
      // Match new pattern with options. 
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine(match.Value);
         if (match.Groups.Count > 1)
            for (int ctr = 1; ctr < match.Groups.Count; ctr++) 
               Console.WriteLine("   Group {0}: '{1}'", ctr, match.Groups[ctr].Value);
      }
   }
}
// The example displays the following output:
//       Drooling dog
//          Group 1: Drooling
//          Group 2: dog
//       
//       Drooling dog
//          Group 1: 'Drooling'
//       Dreaded Deep
//          Group 1: 'Dreaded'
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String 
      Dim input As String = "double dare double Double a Drooling dog The Dreaded Deep"
      
      pattern = "\b(D\w+)\s(d\w+)\b"
      ' Match pattern using default options.
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
         If match.Groups.Count > 1 Then
            For ctr As Integer = 1 To match.Groups.Count - 1 
               Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
            Next
         End If
      Next
      Console.WriteLine()
      
      ' Change regular expression pattern to include options.
      pattern = "\b(D\w+)(?ixn) \s (d\w+) \b"
      ' Match new pattern with options. 
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
         If match.Groups.Count > 1 Then
            For ctr As Integer = 1 To match.Groups.Count - 1 
               Console.WriteLine("   Group {0}: '{1}'", ctr, match.Groups(ctr).Value)
            Next
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'       Drooling dog
'          Group 1: Drooling
'          Group 2: dog
'       
'       Drooling dog
'          Group 1: 'Drooling'
'       Dreaded Deep
'          Group 1: 'Dreaded'

O exemplo define duas expressões regulares.The example defines two regular expressions. A primeira, \b(D\w+)\s(d\w+)\b, corresponde a duas palavras consecutivas que começam com um “D” maiúsculo e um “d” minúsculo.The first, \b(D\w+)\s(d\w+)\b, matches two consecutive words that begin with an uppercase "D" and a lowercase "d". A segunda expressão regular, \b(D\w+)(?ixn) \s (d\w+) \b, usa opções embutidas para modificar esse padrão, conforme descrito na tabela a seguir.The second regular expression, \b(D\w+)(?ixn) \s (d\w+) \b, uses inline options to modify this pattern, as described in the following table. Uma comparação dos resultados confirma o efeito do constructo (?ixn).A comparison of the results confirms the effect of the (?ixn) construct.

PadrãoPattern DescriçãoDescription
\b Iniciar em um limite de palavra.Start at a word boundary.
(D\w+) Corresponder a um “D” maiúsculo seguido por um ou mais caracteres de palavra.Match a capital "D" followed by one or more word characters. Este é o primeiro grupo de captura.This is the first capture group.
(?ixn) Desse ponto em diante, faça comparações sem distinção de maiúsculas e minúsculas, faça apenas capturas explícitas e ignore o espaço em branco no padrão de expressão regular.From this point on, make comparisons case-insensitive, make only explicit captures, and ignore white space in the regular expression pattern.
\s Corresponde a um caractere de espaço em branco.Match a white-space character.
(d\w+) Corresponder a um “d” maiúsculo ou minúsculo seguido por um ou mais caracteres de palavra.Match an uppercase or lowercase "d" followed by one or more word characters. Este grupo não foi capturado porque a opção n (captura explícita) estava habilitada.This group is not captured because the n (explicit capture) option was enabled..
\b Corresponder a um limite de palavra.Match a word boundary.

Comentário embutidoInline Comment

O constructo (?# comment) permite incluir um comentário embutido em uma expressão regular.The (?# comment) construct lets you include an inline comment in a regular expression. O mecanismo de expressões regulares não usa nenhuma parte do comentário na correspondência de padrão, apesar de o comentário estar incluído na cadeia de caracteres que é retornada pelo método Regex.ToString.The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. O comentário é encerrado no primeiro caractere de fechar parênteses.The comment ends at the first closing parenthesis.

O exemplo a seguir repete o primeiro padrão de expressão regular do exemplo na seção anterior.The following example repeats the first regular expression pattern from the example in the previous section. Ele adiciona dois comentários embutidos na expressão regular para indicar se a comparação diferencia maiúsculas de minúsculas.It adds two inline comments to the regular expression to indicate whether the comparison is case-sensitive. O padrão de expressão regular, \b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comparison)d\w+)\b, é definido da seguinte forma.The regular expression pattern, \b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comparison)d\w+)\b, is defined as follows.

PadrãoPattern DescriçãoDescription
\b Iniciar em um limite de palavra.Start at a word boundary.
(?# case-sensitive comparison) Um comentário.A comment. Não afeta o comportamento de correspondência.It does not affect pattern-matching behavior.
(D\w+) Corresponder a um “D” maiúsculo seguido por um ou mais caracteres de palavra.Match a capital "D" followed by 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.
(?ixn) Desse ponto em diante, faça comparações sem distinção de maiúsculas e minúsculas, faça apenas capturas explícitas e ignore o espaço em branco no padrão de expressão regular.From this point on, make comparisons case-insensitive, make only explicit captures, and ignore white space in the regular expression pattern.
(?#case-insensitive comparison) Um comentário.A comment. Não afeta o comportamento de correspondência.It does not affect pattern-matching behavior.
(d\w+) Corresponder a um “d” maiúsculo ou minúsculo seguido por um ou mais caracteres de palavra.Match an uppercase or lowercase "d" followed by one or more word characters. Este é o segundo grupo de captura.This is the second capture group.
\b Corresponder a um limite de palavra.Match a word boundary.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comparison)d\w+)\b";
      Regex rgx = new Regex(pattern);
      string input = "double dare double Double a Drooling dog The Dreaded Deep";

      Console.WriteLine("Pattern: " + pattern.ToString());
      // Match pattern using default options.
      foreach (Match match in rgx.Matches(input))
      {
         Console.WriteLine(match.Value);
         if (match.Groups.Count > 1)
         {
            for (int ctr = 1; ctr <match.Groups.Count; ctr++) 
               Console.WriteLine("   Group {0}: {1}", ctr, match.Groups[ctr].Value);
         }
      }
   }
}
// The example displays the following output:
//    Pattern: \b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comp
//    arison)d\w+)\b
//    Drooling dog
//       Group 1: Drooling
//    Dreaded Deep
//       Group 1: Dreaded
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comparison)d\w+)\b"
      Dim rgx As New Regex(pattern)
      Dim input As String = "double dare double Double a Drooling dog The Dreaded Deep"

      Console.WriteLine("Pattern: " + pattern.ToString())
      ' Match pattern using default options.
      For Each match As Match In rgx.Matches(input)
         Console.WriteLine(match.Value)
         If match.Groups.Count > 1 Then
            For ctr As Integer = 1 To match.Groups.Count - 1 
               Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
            Next
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'    Pattern: \b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comp
'    arison)d\w+)\b
'    Drooling dog
'       Group 1: Drooling
'    Dreaded Deep
'       Group 1: Dreaded

Comentário de final de linhaEnd-of-Line Comment

Um sinal numérico (#) marca um comentário do modo x, que começa com o caractere # sem escape no final do padrão de expressão regular e continua até o final da linha.A number sign (#)marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. Para usar este constructo, você deve habilitar a opção x (por meio de opções embutidas) ou fornecer o valor RegexOptions.IgnorePatternWhitespace ao parâmetro option ao instanciar o objeto Regex ou chamar um método estático Regex.To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method.

O exemplo a seguir ilustra o constructo do comentário de final de linha.The following example illustrates the end-of-line comment construct. Ele determina se uma cadeia de caracteres é uma cadeia de caracteres de formato de composição que inclui pelo menos um item de formato.It determines whether a string is a composite format string that includes at least one format item. A tabela a seguir descreve os constructos no padrão de expressão regular:The following table describes the constructs in the regular expression pattern:

\{\d+(,-*\d+)*(\:\w{1,4}?)*\}(?x) # Looks for a composite format item.

PadrãoPattern DescriçãoDescription
\{ Corresponder a uma chave de abertura.Match an opening brace.
\d+ Corresponde a um ou mais dígitos decimais.Match one or more decimal digits.
(,-*\d+)* Corresponder a zero ou a uma ocorrência de vírgula, seguida por um sinal de subtração opcional, seguido por um ou mais dígitos decimais.Match zero or one occurrence of a comma, followed by an optional minus sign, followed by one or more decimal digits.
(\:\w{1,4}?)* Corresponder a zero ou a uma ocorrência de dois-pontos, seguido de um a quatro caracteres em branco, mas o mínimo possível.Match zero or one occurrence of a colon, followed by one to four, but as few as possible, white-space characters.
\} Corresponder a uma chave de fechamento.Match a closing brace.
(?x) Habilitar a opção de ignorar espaço em branco no padrão para o comentário de final de linha ser reconhecido.Enable the ignore pattern white-space option so that the end-of-line comment will be recognized.
# Looks for a composite format item. Um comentário de final de linha.An end-of-line comment.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\{\d+(,-*\d+)*(\:\w{1,4}?)*\}(?x) # Looks for a composite format item.";
      string input = "{0,-3:F}";
      Console.WriteLine("'{0}':", input);
      if (Regex.IsMatch(input, pattern))
         Console.WriteLine("   contains a composite format item.");
      else
         Console.WriteLine("   does not contain a composite format item.");
   }
}
// The example displays the following output:
//       '{0,-3:F}':
//          contains a composite format item.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\{\d+(,-*\d+)*(\:\w{1,4}?)*\}(?x) # Looks for a composite format item."
      Dim input As String = "{0,-3:F}"
      Console.WriteLine("'{0}':", input)
      If Regex.IsMatch(input, pattern) Then
         Console.WriteLine("   contains a composite format item.")
      Else
         Console.WriteLine("   does not contain a composite format item.")
      End If
   End Sub
End Module
' The example displays the following output:
'       '{0,-3:F}':
'          contains a composite format item.

Observe que, em vez de fornecer o constructo (?x) na expressão regular, o comentário pode também poderia ter sido reconhecido chamando o método Regex.IsMatch(String, String, RegexOptions) e passando-o para o valor de enumeração RegexOptions.IgnorePatternWhitespace.Note that, instead of providing the (?x) construct in the regular expression, the comment could also have been recognized by calling the Regex.IsMatch(String, String, RegexOptions) method and passing it the RegexOptions.IgnorePatternWhitespace enumeration value.

Consulte tambémSee also