Construções diversas em expressões regulares

As expressões regulares no .NET incluem três construções de linguagem diversas. Um permite ativar ou desativar determinadas opções de correspondência no meio de um padrão de expressão regular. Os dois restantes permitem incluir comentários em uma expressão regular.

Opções em linha

Você pode definir ou desabilitar opções específicas de correspondência de padrões para parte de uma expressão regular usando a sintaxe

(?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. A tabela a seguir descreve cada opção. Para obter mais informações sobre cada opção, consulte Opções de expressão regular.

Opção	Description
i	Correspondência que não diferencia maiúsculas de minúsculas.
m	Modo multilinha.
n	Apenas capturas explícitas. (Parênteses não agem como grupos de captura.)
s	Modo de linha única.
x	Ignore o espaço em branco sem escape e permita comentários no modo x.

Qualquer alteração nas opções de expressão regular definidas pela (?imnsx-imnsx) construção permanece em vigor até o final do grupo de delimitação.

Nota

A (?imnsx-imnsx:construção de agrupamento de subexpressão) fornece funcionalidade idêntica para uma subexpressão. Para obter mais informações, consulte Agrupando construções.

O exemplo a seguir usa as opções , ne para habilitar a insensibilidade a maiúsculas ie x minúsculas e capturas explícitas, além de ignorar o espaço em branco no padrão de expressão regular no meio de uma expressão regular.

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. O primeiro, \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. 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. A comparação dos resultados confirma o efeito do (?ixn) constructo.

Padrão	Description
\b	Comece com um limite de palavras.
(D\w+)	Corresponder a um "D" maiúsculo seguido de um ou mais caracteres de palavras. Este é o primeiro grupo de captura.
(?ixn)	A partir deste ponto, faça comparações sem distinção entre 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.
\s	Corresponder a um caractere de espaço em branco.
(d\w+)	Corresponder a um "d" maiúsculo ou minúsculo seguido de um ou mais caracteres de palavra. Esse grupo não é capturado porque a n opção (captura explícita) foi habilitada.
\b	Corresponder a um limite de palavras.

Comentário Inline

A (?#construção de comentário) permite incluir um comentário embutido em uma expressão regular. O mecanismo de expressão regular não usa nenhuma parte do comentário na correspondência de padrão, embora o comentário seja incluído na cadeia de caracteres retornada pelo Regex.ToString método. O comentário termina no primeiro parêntese de encerramento.

O exemplo a seguir repete o primeiro padrão de expressão regular do exemplo na seção anterior. Ele adiciona dois comentários embutidos à expressão regular para indicar se a comparação diferencia maiúsculas de minúsculas. 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.

Padrão	Description
\b	Comece com um limite de palavras.
(?# case-sensitive comparison)	Um comentário. Não afeta o comportamento de correspondência de padrões.
(D\w+)	Corresponder a um "D" maiúsculo seguido de um ou mais caracteres de palavras. Este é o primeiro grupo de captura.
\s	Corresponder a um caractere de espaço em branco.
(?ixn)	A partir deste ponto, faça comparações sem distinção entre 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.
(?#case-insensitive comparison)	Um comentário. Não afeta o comportamento de correspondência de padrões.
(d\w+)	Corresponder a um "d" maiúsculo ou minúsculo seguido de um ou mais caracteres de palavra. Este é o segundo grupo de captura.
\b	Corresponder a um limite de palavras.

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 fim de linha

Um sinal numérico (#) marca um comentário de modo x, que começa no caractere # sem escape no final do padrão de expressão regular e continua até o final da linha. Para usar essa construção, você deve habilitar a x opção (por meio de opções embutidas) ou fornecer o RegexOptions.IgnorePatternWhitespace valor para o option parâmetro ao instanciar o Regex objeto ou chamar um método estático Regex .

O exemplo a seguir ilustra a construção de comentário de fim de linha. Ele determina se uma cadeia de caracteres é uma cadeia de caracteres de formato composto que inclui pelo menos um item de formato. A tabela a seguir descreve as construções no padrão de expressão regular:

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

Padrão	Description
\{	Combine uma chave de abertura.
\d+	Corresponder a um ou mais dígitos decimais.
(,-*\d+)*	Corresponder a zero ou a uma ocorrência de vírgula, seguida de um sinal de subtração opcional, seguido de um ou mais dígitos decimais.
(\:\w{1,4}?)*	Corresponder zero ou uma ocorrência de dois pontos, seguido de um a quatro, mas o menor número possível de caracteres de espaço em branco.
\}	Combine uma chave de fechamento.
(?x)	Habilite a opção de espaço em branco do padrão ignorar para que o comentário de fim de linha seja reconhecido.
# Looks for a composite format item.	Um comentário de fim de linha.

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 a (?x) construção na expressão regular, o comentário também poderia ter sido reconhecido chamando o Regex.IsMatch(String, String, RegexOptions) método e passando-lhe o RegexOptions.IgnorePatternWhitespace valor de enumeração.

Consulte também

• Linguagem de Expressão Regular - Referência Rápida