Opções de expressões regulares

Por padrão, a comparação de uma seqüência de caracteres de entrada com qualquer caractere literal em um padrão de expressão regular diferencia maiúsculas de minúsculas, o espaço em branco em um padrão de expressão regular é interpretado como caracteres literais de espaço em branco e grupos de captura em uma expressão regular são nomeados, implicitamente, bem como explicitamente. Você pode modificar esses e vários outros aspectos do comportamento de expressão regular do padrão, especificando opções de expressão regular. Essas opções, estão listadas na tabela a seguir, podem estar incluído in-line como parte do padrão de expressão regular ou eles podem ser fornecidos para um System.Text.RegularExpressions.Regex o construtor de classe ou estático padrão correspondente método como um System.Text.RegularExpressions.RegexOptions valor de enumeração.

Especificando as opções

Você pode especificar opções de expressões regulares em uma das três maneiras:

• No options parâmetro de um System.Text.RegularExpressions.Regex Construtor de classe ou estático (Shared em Visual Basic) no método de correspondência de padrões, como Regex.Regex(String, RegexOptions) ou Regex.Match(String, String, RegexOptions). O options parâmetro é uma combinação de OR bit a bit de System.Text.RegularExpressions.RegexOptions enumerados valores.

  O exemplo a seguir fornece uma ilustração. Ele usa o options parâmetro do Regex.Match(String, String, RegexOptions) método para ativar a correspondência de maiúsculas e minúsculas e ignorar espaços em branco padrão ao identificar palavras que começam com a letra "d".

  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.      
  

  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.      
  

• Aplicando opções de linha em um padrão de expressão regular com a sintaxe (?imnsx-imnsx). A opção aplica o padrão do ponto em que a opção é definida para o final do padrão ou o ponto em que a opção é não definido por outra opção de linha. Para obter mais informações, consulte o tópico Construtores Diversos.

  O exemplo a seguir fornece uma ilustração. Ele usa as opções de linha para ativar a correspondência de maiúsculas e minúsculas e ignorar espaços em branco padrão ao identificar palavras que começam com a letra "d".

  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.      
  

  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.      
  

• Aplicando opções de linha em um determinado agrupamento construir em um padrão de expressão regular com a sintaxe (?imnsx-imnsx:subexpressão). 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. (? é uma parte fixa da construção de linguagem sintaxe é necessária se as opções estão ativadas ou desativadas.) A opção aplica-se somente a esse grupo. Para obter mais informações, consulte Agrupando Construtores.

  O exemplo a seguir fornece uma ilustração. Ele usa as opções de linha em uma construção de agrupamento para ativar a correspondência de maiúsculas e minúsculas e para ignorar espaços em branco padrão ao identificar palavras que começam com a letra "d".

  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.      
  

  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.      
  

Se as opções são embutidas especificada, um sinal de subtração (-) antes de uma opção ou o conjunto de opções desativa essas opções. Por exemplo, o embutido construir (?ix-ms) ativa o RegexOptions.IgnoreCase e RegexOptions.IgnorePatternWhitespace as opções e desativa o RegexOptions.Multiline e RegexOptions.Singleline Opções. Todas as opções de expressão regular estão desativadas por padrão.

As cinco opções de expressão regular a seguir podem ser definidas tanto com o parâmetro options e in-line:

• RegexOptions.IgnoreCase

• RegexOptions.Multiline

• RegexOptions.Singleline

• RegexOptions.ExplicitCapture

• RegexOptions.IgnorePatternWhitespace

As cinco opções de expressão regular a seguir podem ser definidas usando o options parâmetro, mas não pode ser definido in-line:

• RegexOptions.None

• RegexOptions.Compiled

• RegexOptions.RightToLeft

• RegexOptions.CultureInvariant

• RegexOptions.ECMAScript

Determinando as opções

Você pode determinar quais opções foram fornecidas a uma Regex objeto quando ele foi instanciado, recuperando o valor de somente leitura Regex.Options propriedade. Esta propriedade é particularmente útil para determinar as opções definidas para uma expressão regular compilada, criada pelo Regex.CompileToAssembly método.

Para testar a presença de qualquer opção exceto RegexOptions.None, executar uma operação e com o valor da Regex.Options propriedade e o RegexOptions valor no qual você está interessado. Em seguida, teste se o resultado é igual ao RegexOptions valor. Os testes de exemplo a seguir se o RegexOptions.IgnoreCase opção foi definido.

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

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

Para testar RegexOptions.None, determinar se o valor de Regex.Options propriedade é igual a RegexOptions.None, conforme o exemplo a seguir ilustra.

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

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

As seções a seguir listam as opções aceitas pela expressão regular na.NET Framework.

Opções padrão

O RegexOptions.None opção indica que foram especificadas sem opções, e o mecanismo de expressão regular usa seu comportamento padrão. Isto inlcui o seguinte:

• O padrão é interpretado como um canônico em vez de uma expressão regular do ECMAScript.

• O padrão de expressão regular é correspondido na seqüência de entrada da esquerda para a direita.

• As comparações diferenciam maiúsculas de minúsculas.

• O ^ e $ elementos de linguagem corresponde ao início e fim da seqüência de caracteres de entrada.

• O . o elemento de linguagem corresponde a cada caractere, exceto \n.

• Qualquer espaço em branco em um padrão de expressão regular é interpretado como um caractere de espaço literal.

• As convenções da cultura atual são usadas ao comparar o padrão para a seqüência de caracteres de entrada.

• Grupos de captura no padrão de expressão regular são implícita como explícita.

Porque o RegexOptions.None opção representa o comportamento padrão do mecanismo de expressões regulares, é raramente explicitamente especificado em uma chamada de método. Um construtor ou um método estático de correspondência de padrões sem um options parâmetro é chamado em vez disso.

Voltar ao início

Correspondência de maiúsculas e minúsculas

O IgnoreCase opção, ou o i opção in-line, fornece a correspondência de maiúsculas e minúsculas. Por padrão, as convenções de maiúsculas e minúsculas da cultura atual são usadas.

O exemplo a seguir define um padrão de expressão regular, \bthe\w*\b, que corresponde a todas as palavras que comecem com "a". Porque a primeira chamada para o Match método usa a comparação de padrão diferencia maiúsculas de minúsculas, a saída indica que a seqüência de caracteres "A" que começa a sentença não for atendida. Ele é comparado de Match método é chamado com opções definidas para IgnoreCase.

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.

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.

O exemplo seguinte modifica o padrão de expressão regular do exemplo anterior para usar opções de linha em vez da options parâmetro para fornecer uma comparação diferenciando maiúsculas de minúsculas. O primeiro padrão define a opção de maiúsculas e minúsculas em uma construção de agrupamento que se aplica somente a letra "t" na seqüência de caracteres "a". Como a construção de opção ocorre no início do padrão, o segundo padrão aplica-se a opção de maiúsculas e minúsculas para toda a expressão regular.

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.

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.

Voltar ao início

Modo de várias linhas

O RegexOptions.Multiline opção, ou o m opção embutida, permite que o mecanismo de expressões regulares lidar com uma seqüência de caracteres de entrada que é composto de várias linhas. Ele altera a interpretação de ^ e $ elementos de linguagem para que elas coincidam com o início e fim de uma linha, em vez de início e fim da seqüência de caracteres de entrada.

Por padrão, $ corresponde somente o final da seqüência de caracteres de entrada. Se você especificar o RegexOptions.Multiline opção, ela coincide com o caractere de nova linha (\n) ou o fim da seqüência de caracteres de entrada. No entanto, ele não corresponde o retorno de carro/linha combinação de caracteres de alimentação. Para corresponder com êxito-las, usar a subexpressão \r?$ em vez de apenas $.

O exemplo a seguir extrai o bowlers' nomes e pontuações e adiciona-los para um SortedList<TKey, TValue> coleção que classifica em ordem decrescente. O Matches método é chamado duas vezes. Na primeira chamada do método, a expressão regular é ^(\w+)\s(\d+)$ e as opções não definido. Como mostra a saída, porque o mecanismo de expressão regular não corresponde ao padrão de entrada junto com o início e fim da seqüência de entrada, nenhuma correspondência for encontrada. Na segunda chamada de método, a expressão regular é alterada para ^(\w+)\s(\d+)\r?$ e as opções são definidas como RegexOptions.Multiline. Como mostra a saída, os nomes e as pontuações são comparadas com êxito e as pontuações são exibidas em ordem decrescente.

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

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

O padrão de expressão regular ^(\w+)\s(\d+)\r*$ é definido como mostrado na tabela a seguir.

O exemplo a seguir é equivalente ao anterior, exceto que ele usa a opção de linha (?m) para definir a opção de várias linhas.

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

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

Voltar ao início

Modo de linha única

O RegexOptions.Singleline opção, ou o s opção in-line, faz com que o mecanismo de expressões regulares tratar a seqüência de caracteres de entrada, como se ele é composto de uma única linha. Ele faz isso alterando o comportamento do período (.) o elemento de linguagem, de modo que ele corresponde a cada caractere, em vez de correspondência de cada caractere, exceto para o caractere de nova linha \n ou \u000A.

O exemplo a seguir ilustra como o comportamento da . o elemento de linguagem altera quando você usa o RegexOptions.Singleline opção. A expressão regular ^.+ começa no início da seqüência de caracteres e corresponde a cada caractere. 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 ele não corresponde a \n. Porque o RegexOptions.Singleline opção interpreta a seqüência de entrada inteira como uma única linha, corresponde a cada caractere na seqüência de entrada, incluindo \n.

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\.

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\.

O exemplo a seguir é equivalente ao anterior, exceto que ele usa a opção de linha (?s) para habilitar o modo de linha única.

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\.

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\.

Voltar ao início

Captura explícita apenas

Por padrão, os grupos de captura são definidos pelo uso de parênteses no padrão de expressão regular. Grupos nomeados são atribuídos a um nome ou número o (?<nome> subexpressão) opção de idioma, enquanto os grupos sem nome são acessíveis pelo índice. No GroupCollection o objeto, sem nome grupos preceder grupos nomeados.

Construções de agrupamento geralmente são usadas apenas para aplicar quantificadores para vários elementos de linguagem e subseqüências capturadas são de nenhum interesse. Por exemplo, se a seguinte expressão regular:

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

destina-se somente a extrair sentenças que terminam com um período, o ponto de exclamação ou ponto de interrogação de um documento, apenas a sentença resultante (que é representado pela Match objeto) é de interesse. Não são as palavras individuais na coleção.

A captura de grupos não serão usados posteriormente pode ser cara, porque o mecanismo de expressão regular deve preencher ambos os GroupCollection e CaptureCollection objetos da coleção. Como alternativa, você pode usar o RegexOptions.ExplicitCapture opção ou o n opção embutido para especificar as capturas válidas somente são explicitamente chamadas ou numeradas grupos que são designados pela (?<nome> subexpressão) construir.

O exemplo a seguir exibe informações sobre as correspondências retornado pelo \b\(?((\w+),?\s?)+[\.!?]\)? padrão de expressão regular, quando o Match método é chamado com e sem a RegexOptions.ExplicitCapture opção. Como a saída do primeiro método, chame mostra, o mecanismo de expressão regular preenche integralmente o GroupCollection e CaptureCollection os objetos de coleção com informações sobre subseqüências capturadas. Porque o segundo método é chamado com options definido como RegexOptions.ExplicitCapture, ele não captura informações sobre grupos.

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.

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.

O padrão de expressão regular \b\(?((?>\w+),?\s?)+[\.!?]\)? é definido como mostrado na tabela a seguir.

Você também pode usar o (?n) elemento embutido para suprimir capturas automáticas. O exemplo seguinte modifica o padrão de expressão regular anterior para usar o (?n) o elemento embutido em vez da RegexOptions.ExplicitCapture opção.

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.

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.

Finalmente, você pode usar o elemento de grupo embutido (?n:) para suprimir capturas automáticas em uma base por grupo. O exemplo seguinte modifica o padrão anterior para suprimir capturas sem nome do grupo externo, ((?>\w+),?\s?). Observe que isso suprime capturas sem nome no grupo interno.

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.

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.

Voltar ao início

Expressões regulares compilados

Por padrão, as expressões regulares na.NET Framework são interpretados. Quando um Regex o objeto é instanciado ou estático Regex método é chamado, o padrão de expressão regular é analisado em um conjunto de opcodes personalizados, e um intérprete usa desses opcodes para executar a expressão regular. Isso envolve uma compensação: O custo de inicializar o mecanismo de expressão regular é minimizado às custas do desempenho em tempo de execução.

Você pode usar compilado em vez de interpretada expressões regulares, usando o RegexOptions.Compiled opção. Nesse caso, quando um padrão é passado para o mecanismo de expressão regular, ela é analisada em um conjunto de opcodes e convertida em Microsoft intermediate language (MSIL), que pode ser passado diretamente para o common language runtime. Compilado expressões regulares maximizar o desempenho em tempo de execução às custas de tempo de inicialização.

Você pode usar compiladas expressões regulares em chamadas para estáticos e expressões regulares de instância. Em expressões regulares de estáticas, o RegexOptions.Compiled opção é passada para o options parâmetro da expressão regular a correspondência de padrões método. Expressões regulares de instância, ele é passado para o options parâmetro da Regex Construtor de classe. Em ambos os casos, resulta em melhor desempenho.

No entanto, essa melhoria no desempenho ocorre apenas nas seguintes condições:

• A Regex o objeto que representa uma expressão regular é usado em várias chamadas para a expressão regular de correspondência de padrão de métodos.

• O Regex objeto não é permitido passar fora do escopo, portanto, pode ser reutilizado.

• Uma expressão regular estática é usada em várias chamadas para métodos de correspondência de padrão de expressão regular. (A melhoria de desempenho é possível porque o mecanismo de expressão regular armazenado em cache usadas em chamadas de método estático de expressões regulares).

Voltar ao início

Ignorar espaços em branco

Por padrão, o espaço em branco em um padrão de expressão regular é significativo; ela força o mecanismo de expressões regulares para coincidir com um caractere de espaço em branco na seqüência de entrada. Dessa forma, a expressão regular "\b\w+\s" and "\b\w+ " são aproximadamente equivalentes expressões regulares. Além disso, quando o sinal numérico (#) é encontrado em um padrão de expressão regular, ele é interpretado como um caractere literal a ser correspondido.

O RegexOptions.IgnorePatternWhitespace opção, ou o x opção in-line, altera esse comportamento padrão da seguinte maneira:

• Escape espaço em branco no padrão de expressão regular será ignorado. Para fazer parte de um padrão de expressão regular, caracteres de espaço em branco devem ser antecedidas (por exemplo, como \s ou "\ ").

  Observação

  O espaço em branco dentro de uma classe de caracteres é interpretado literalmente, independentemente do uso de RegexOptions.IgnorePatternWhitespace opção.Por exemplo, o padrão de expressão regular [ .,;:] corresponde a qualquer caractere único de espaço em branco, período, vírgula, ponto e vírgula ou dois-pontos.

• O sinal numérico (#) é interpretado como o início de um comentário, em vez de como um caractere literal. Todo o texto padrão da expressão regular do caractere # para o final da seqüência de caracteres é interpretado como um comentário.

A ativação dessa opção ajuda a simplificar as expressões regulares que freqüentemente são difíceis de analisar e compreender. Ele melhora a legibilidade e torna possível documentar uma expressão regular.

O exemplo a seguir define o padrão de expressão regular a seguir:

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

Esse padrão é semelhante ao padrão definido no Apenas capturas de explícita seção, exceto que ele usa o RegexOptions.IgnorePatternWhitespace opção para ignorar o padrão de espaço em branco.

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.

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?)+[\.!?]\)?";

      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.

O exemplo a seguir usa a opção de linha (?x) para ignorar o padrão de espaço em branco.

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.

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.

Voltar ao início

Modo da direita para a esquerda.

Por padrão, o mecanismo de expressão regular procura da esquerda para a direita. Você pode reverter a direção da pesquisa usando o RegexOptions.RightToLeft opção. A pesquisa começará automaticamente na posição do última caractere da seqüência de caracteres. Para métodos de correspondência de padrões que incluem um iniciando apresente o parâmetro, como Regex.Match(String, Int32), a posição inicial é o índice da posição de caractere da extrema direita, em que a pesquisa deve começar.

O RegexOptions.RightToLeft opção altera a direção da pesquisa apenas; ele não interpretará o padrão de expressão regular da direita para esquerda. Por exemplo, a expressão regular \bb\w+\s corresponde a palavras que começam com a letra "b" seguido por um caractere de espaço em branco. No exemplo a seguir, a seqüência de caracteres de entrada consiste em três palavras que incluam um ou mais "b" caracteres. A primeira palavra começa com "b", o segundo termina com "b" e o terceiro inclui dois "b" caracteres no meio da palavra. Como mostra a saída do exemplo, apenas a primeira palavra coincide com o padrão de expressão regular.

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.

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.

Observe também que a declaração de visão antecipada (o (?=subexpressão) elemento de linguagem) e a declaração de lookbehind (o (?<=subexpressão) elemento de linguagem) não alterar a direção. As declarações de lookahead examinar para a direita; as declarações de lookbehind aparência para a esquerda. Por exemplo, a expressão regular (?<=\d{1,2}\s)\w+,*\s\d{4} usa a declaração de lookbehind para testar uma data que precede o nome de um mês. Em seguida, a expressão regular corresponde o mês e ano. Para obter informações sobre o assertsions lookahead e lookbehind, consulte Agrupando Construtores.

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.

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.

O padrão de expressão regular é definido como mostrado na tabela a seguir.

Voltar ao início

Comportamento de correspondência do ECMAScript

Por padrão, o mecanismo de expressão regular usa canônico comportamento ao fazer a correspondência de um padrão de expressão regular para entrada de texto. No entanto, você pode instruir o mecanismo de expressão regular para usar ECMAScript correspondência comportamento especificando a RegexOptions.ECMAScript opção.

O RegexOptions.ECMAScript opção pode ser combinada somente com o RegexOptions.IgnoreCase e RegexOptions.Multiline Opções. O uso de qualquer outra opção em uma expressão regular resulta em um ArgumentOutOfRangeException.

O comportamento de expressões regulares canônicas e ECMAScript difere em três áreas: sintaxe de classe do caractere, auto-referência grupos de captura e octal versus retrorreferência interpretação.

• Sintaxe de classe de caractere. Como canônicas expressões regulares oferecem suporte a Unicode e não ECMAScript, classes de caracteres no ECMAScript tem uma sintaxe mais limitada e alguns elementos de linguagem de classe de caractere têm um significado diferente. Por exemplo, ECMAScript não oferece suporte a elementos de linguagem como, por exemplo, os elementos de bloco ou de categoria Unicode \p e \P. Da mesma forma, o \w elemento, que corresponde a um caractere no word, equivale ao [a-zA-Z_0-9] classe de caracteres, ao usar ECMAScript e [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}] ao usar o comportamento canônico. Para obter mais informações, consulte Classes de Caracteres.

  O exemplo a seguir ilustra a diferença entre canônico e correspondência de padrões do ECMAScript. Ele define uma expressão regular, \b(\w+\s*)+, que corresponde a palavras seguidas por caracteres de espaço em branco. A entrada consiste em duas seqüências de caracteres, que usa o conjunto de caracteres latinos e outro que usa o conjunto de caracteres cirílico. Como mostra a saída, a chamada para o Regex.IsMatch(String, String, RegexOptions) Falha do método que usa a correspondência do ECMAScript coincidir com as palavras cirílica, enquanto a chamada do método que usa a correspondência canônico corresponder essas palavras.

  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.
  

  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.
  

• Grupos de captura de auto-referência. Uma classe de captura de expressões regulares com um referência anterior a si mesma deve ser atualizada a cada iteração de captura. Como mostra o exemplo a seguir, este recurso permite que a expressão regular ((a+)(\1) ?)+ para coincidir com a seqüência de caracteres de entrada " aaaaaa de aa aaaa" ao usar ECMAScript, mas não ao usar a correspondência canônico.

  A expressão regular é definida como mostrado na tabela a seguir.

  Padrão	Descrição
  (+)	Coincidir com a letra "a" uma ou mais vezes. Este é o segundo grupo de capturando.
  (\1)	Corresponde a subseqüência capturada pelo primeiro grupo de capturando. Este é o terceiro grupo de capturando.
  ?	Corresponde a zero ou um caracteres de espaço.
  ((a+)(\1) ?)+	Correspondem ao padrão de uma ou mais "a" caracteres seguidos de uma seqüência de caracteres que corresponde ao primeiro grupo de capturando seguido de zero ou um espaço de caracteres de uma ou mais vezes. Este é o primeiro grupo de capturando.

• Resolução ambigüidades entre escapa octal e referências anteriores. A tabela a seguir resume as diferenças entre octais e interpretação de referência anterior através de expressões regulares canônicas e ECMAScript.

  Expressão regular	Comportamento canônico	Comportamento ECMAScript
  \0seguido por dígitos de 0 a 2 octais	Interprete como um octal. Por exemplo, \044 sempre é interpretado como um valor octal e significa "$".	Mesmo comportamento.
  \seguido por um dígito de 1 a 9, seguido de nenhum dígitos decimais adicionais,	Interprete como referência anterior. Por exemplo, \9 sempre significa retrorreferência 9, mesmo se um nonas captura o grupo não existe. Se o grupo de captura não existir, o analisador de expressões regulares lança um ArgumentException.	Se um único dígito decimal capturando grupo existe, retrorreferência esse dígito. Caso contrário, interprete o valor como um literal.
  \seguido por um dígito de 1 a 9, seguido de dígitos decimais adicionais	Interprete os dígitos como um valor decimal. Se existir a esse grupo de captura, interpretará a expressão como referência anterior. Caso contrário, interpretar os dígitos octais líderes até octal 377; ou seja, considere somente 8 bits baixos do valor. Interprete os dígitos restantes como literais. Por exemplo, na expressão \3000, se o grupo de captura 300 existe, interpretar como retrorreferência 300; Se não existir um grupo de captura 300, interprete como 300 octal, seguido por 0.	Interprete como uma retrorreferência convertendo quantos dígitos possível para um valor decimal que pode se referir a uma captura. Se nenhum dígito pode ser convertido, interpretar como um octal usando os dígitos octais líderes até octal 377; interprete os dígitos restantes como literais.

Voltar ao início

Comparação usando a cultura invariável

Por padrão, quando o mecanismo de expressão regular executa comparações diferenciando maiúsculas de minúsculas, ele usa as convenções de maiúsculas e minúsculas da cultura atual para determinar os caracteres maiúsculos e minúsculos equivalentes.

No entanto, esse comportamento é indesejável para alguns tipos de comparações, particularmente quando comparando a entrada do usuário para os nomes dos recursos do sistema, como, por exemplo, senhas, arquivos ou URLs. O exemplo a seguir ilustra como o cenário. O código destina-se para bloquear o acesso a qualquer recurso cujo URL é antecedido pelo FILE://. A expressão regular tenta uma correspondência de maiúsculas e minúsculas com a seqüência de caracteres usando a expressão regular $FILE://. No entanto, quando a cultura atual do sistema é tr-TR (Turquia-turco), "I" não é o equivalente maiúsculo "i". Como resultado, a chamada para o Regex.IsMatch método retorna false, e é permitido o acesso ao arquivo.

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.

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.

Em vez de usar as comparações de maiúsculas e minúsculas da cultura atual, você pode especificar o RegexOptions.CultureInvariant opção para ignorar as diferenças culturais no idioma e use as convenções da cultura invariável.

O exemplo a seguir é idêntico ao exemplo anterior, exceto que estática Regex.IsMatch(String, String, RegexOptions) método é chamado com opções que incluem RegexOptions.CultureInvariant. Mesmo quando a cultura atual é definida como Turco (Turquia), o mecanismo de expressão regular é capaz de corresponder com êxito o "Arquivo" e "arquivo" e bloquear o acesso ao recurso de arquivo.

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.

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.

Voltar ao início

Consulte também

Conceitos

Elementos de linguagem das expressões regulares