Construtores de Referência Passada

Referências anteriores fornecem uma maneira conveniente para identificar um repetidas de caracteres ou subseqüência de caracteres dentro de uma seqüência. Por exemplo, a seqüência de caracteres de entrada contém várias ocorrências de uma subseqüência de caracteres arbitrária, você pode coincidir com a primeira ocorrência com um grupo de captura e, em seguida, use uma retrorreferência para corresponder às ocorrências subseqüentes da subseqüência.

A.NET Framework define elementos de idioma separados para se referir a grupos de captura numerados e nomeados. Para obter mais informações sobre a captura de grupos, consulte Agrupando Construtores.

Referências anteriores numeradas

Referência numerada anterior usa a seguinte sintaxe:

\número

onde número é a posição ordinal de um grupo de captura na expressão regular. Por exemplo, \4 coincide com o conteúdo do quarto captura grupo. Se número não é definido no padrão de expressão regular, ocorre de um erro de análise e o mecanismo de expressão regular lança um ArgumentException. Por exemplo, a expressão regular \b(\w+)\s\1 é válido, pois (\w+) é o primeiro e capturando somente o grupo na expressão. Por outro lado, \b(\w+)\s\2 é inválido e lança uma exceção de argumento, porque não há nenhum grupo de captura numerado \2.

Observe a ambigüidade entre os códigos de escape octais (como \16) e \número referências anteriores que usam a notação do mesma. Essa ambigüidade é resolvida da seguinte maneira:

• As expressões \1 por \9 são sempre interpretados como referências anteriores e não como códigos octal.

• Se o primeiro dígito de uma expressão de diversos dígitos é 8 ou 9 (como \80 ou \91), a expressão conforme interpretado como um literal.

• Expressões de \10 e maior são consideradas referências anteriores, se houver uma retrorreferência correspondente a esse número; Caso contrário, eles são interpretados como códigos octais.

• Se uma expressão regular contiver uma referência anterior a um número indefinido de grupo, ocorre um erro de análise e o mecanismo de expressão regular lança um ArgumentException.

Se a ambigüidade é um problema, você pode usar o \k<nome> notação, o que é inequívoca e não pode ser confundidas com códigos de caracteres octal. Da mesma forma, hexadecimal códigos, como \xdd não são ambíguas e não pode ser confundida com referências anteriores.

O exemplo a seguir localiza palavras repetidas de caracteres em uma seqüência de caracteres. Ele define uma expressão regular, (\w)\1, que consiste o elementos a seguir.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\w)\1"
      Dim input As String = "trellis llama webbing dresser swagger"
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("Found '{0}' at position {1}.", _
                           match.Value, match.Index)
      Next   
   End Sub
End Module
' The example displays the following output:
'       Found 'll' at position 3.
'       Found 'll' at position 8.
'       Found 'bb' at position 16.
'       Found 'ss' at position 25.
'       Found 'gg' at position 33.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\w)\1";
      string input = "trellis llama webbing dresser swagger";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("Found '{0}' at position {1}.", 
                           match.Value, match.Index);
   }
}
// The example displays the following output:
//       Found 'll' at position 3.
//       Found 'll' at position 8.
//       Found 'bb' at position 16.
//       Found 'ss' at position 25.
//       Found 'gg' at position 33.

Referências anteriores de nomeado

Uma retrorreferência nomeada é definida usando a seguinte sintaxe:

\k<name>

Ou:

\k'name'

onde nome é o nome de um grupo de captura definido no padrão de expressão regular. Se nome não é definido no padrão de expressão regular, ocorre de um erro de análise e o mecanismo de expressão regular lança um ArgumentException.

O exemplo a seguir localiza palavras repetidas de caracteres em uma seqüência de caracteres. Ele define uma expressão regular, (?<char>\w)\k<char>, que consiste o elementos a seguir.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(?<char>\w)\k<char>"
      Dim input As String = "trellis llama webbing dresser swagger"
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("Found '{0}' at position {1}.", _
                           match.Value, match.Index)
      Next   
   End Sub
End Module
' The example displays the following output:
'       Found 'll' at position 3.
'       Found 'll' at position 8.
'       Found 'bb' at position 16.
'       Found 'ss' at position 25.
'       Found 'gg' at position 33.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(?<char>\w)\k<char>";
      string input = "trellis llama webbing dresser swagger";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("Found '{0}' at position {1}.", 
                           match.Value, match.Index);
   }
}
// The example displays the following output:
//       Found 'll' at position 3.
//       Found 'll' at position 8.
//       Found 'bb' at position 16.
//       Found 'ss' at position 25.
//       Found 'gg' at position 33.

Observe que nome também pode ser a representação de seqüência de caracteres de um número. Por exemplo, o exemplo a seguir usa a expressão regular (?<2>\w)\k<2> Localizar dobrou caracteres de palavra em uma seqüência de caracteres.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(?<2>\w)\k<2>"
      Dim input As String = "trellis llama webbing dresser swagger"
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("Found '{0}' at position {1}.", _
                           match.Value, match.Index)
      Next   
   End Sub
End Module
' The example displays the following output:
'       Found 'll' at position 3.
'       Found 'll' at position 8.
'       Found 'bb' at position 16.
'       Found 'ss' at position 25.
'       Found 'gg' at position 33.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(?<2>\w)\k<2>";
      string input = "trellis llama webbing dresser swagger";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("Found '{0}' at position {1}.", 
                           match.Value, match.Index);
   }
}
// The example displays the following output:
//       Found 'll' at position 3.
//       Found 'll' at position 8.
//       Found 'bb' at position 16.
//       Found 'ss' at position 25.
//       Found 'gg' at position 33.

Correspondência que referências anteriores

Uma referência anterior refere-se à definição mais recente de um grupo (a definição mais imediatamente à esquerda, quando a correspondência for da esquerda para a direita). Quando faz um grupo que várias capturas, uma retrorreferência refere-se à captura mais recente.

O exemplo a seguir inclui um padrão de expressão regular, (?<1>a)(?<1>\1b)*, que redefine o \ 1 chamado grupo. A tabela a seguir descreve cada padrão de expressão regular.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(?<1>a)(?<1>\1b)*"
      Dim input As String = "aababb"
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("Match: " + match.Value)
         For Each group As Group In match.Groups
            Console.WriteLIne("   Group: " + group.Value)
         Next
      Next
   End Sub
End Module
' The example display the following output:
'          Group: aababb
'          Group: abb

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(?<1>a)(?<1>\1b)*";
      string input = "aababb";
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine("Match: " + match.Value);
         foreach (Group group in match.Groups)
            Console.WriteLine("   Group: " + group.Value);
      }
   }
}
// The example displays the following output:
//          Group: aababb
//          Group: abb

Em comparação a expressão regular com a seqüência de caracteres de entrada ("aababb"), o mecanismo de expressão regular realiza as seguintes operações:

1. Ele começa no início da seqüência de caracteres e corresponde com êxito "a" com a expressão (?<1>a). O valor de 1 grupo é agora "a".

2. Ele avança para o segundo caractere e corresponde a seqüência de caracteres "ab" com êxito com a expressão \1b, ou "ab". Em seguida, atribui o resultado "ab" to \1.

3. Ele avança para o quarto caractere. A expressão (?<1>\1b) está a ser correspondido zero ou mais vezes, portanto, com êxito corresponda a seqüência de caracteres "abb" com a expressão \1b. Ele atribui o resultado, "abb" Voltar ao \1.

Neste exemplo, * é um quantificador loop – ele é avaliado repetidamente até que o mecanismo de expressão regular não pode corresponder a ele define o padrão de. Quantificadores de loop não limpam definições de grupo.

Se um grupo não capturou a qualquer uma das subseqüências, uma referência anterior a esse grupo está indefinido e nunca corresponde. Isso é ilustrado pelo padrão de expressão regular \b(\p{Lu}{2})(\d{2})?(\p{Lu}{2})\b, que é definido da seguinte maneira:

Uma seqüência de caracteres de entrada pode corresponder a essa expressão regular, mesmo se os dois dígitos decimais que são definidos pelo segundo grupo de capturando não estão presentes. O exemplo a seguir mostra que, mesmo que a correspondência for bem-sucedida, um grupo de capturando vazio é encontrado entre dois grupos de capturando com êxito.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(\p{Lu}{2})(\d{2})?(\p{Lu}{2})\b"
      Dim inputs() As String = { "AA22ZZ", "AABB" }
      For Each input As String In inputs
         Dim match As Match = Regex.Match(input, pattern)
         If match.Success Then
            Console.WriteLine("Match in {0}: {1}", input, match.Value)
            If match.Groups.Count > 1 Then
               For ctr As Integer = 1 To match.Groups.Count - 1
                  If match.Groups(ctr).Success Then
                     Console.WriteLine("Group {0}: {1}", _
                                       ctr, match.Groups(ctr).Value)
                  Else
                     Console.WriteLine("Group {0}: <no match>", ctr)
                  End If      
               Next
            End If
         End If
         Console.WriteLine()
      Next      
   End Sub
End Module
' The example displays the following output:
'       Match in AA22ZZ: AA22ZZ
'       Group 1: AA
'       Group 2: 22
'       Group 3: ZZ
'       
'       Match in AABB: AABB
'       Group 1: AA
'       Group 2: <no match>
'       Group 3: BB

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\p{Lu}{2})(\d{2})?(\p{Lu}{2})\b";
      string[] inputs = { "AA22ZZ", "AABB" };
      foreach (string input in inputs)
      {
         Match match = Regex.Match(input, pattern);
         if (match.Success)
         {
            Console.WriteLine("Match in {0}: {1}", input, match.Value);
            if (match.Groups.Count > 1)
            {
               for (int ctr = 1; ctr <= match.Groups.Count - 1; ctr++)
               {
                  if (match.Groups[ctr].Success)
                     Console.WriteLine("Group {0}: {1}", 
                                       ctr, match.Groups[ctr].Value);
                  else
                     Console.WriteLine("Group {0}: <no match>", ctr);
               }
            }
         }
         Console.WriteLine();
      }      
   }
}
// The example displays the following output:
//       Match in AA22ZZ: AA22ZZ
//       Group 1: AA
//       Group 2: 22
//       Group 3: ZZ
//       
//       Match in AABB: AABB
//       Group 1: AA
//       Group 2: <no match>
//       Group 3: BB

Consulte também

Conceitos

Elementos de linguagem das expressões regulares