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.
Observação
Uma sintaxe separada é usada para se referir a numeradas de captura de grupos de seqüências de caracteres de substituição e nomeado.Para obter mais informações, consulte Substituições.
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.
Elemento |
Descrição |
|---|---|
(\w) |
Corresponde a um caractere de palavra e atribuí-lo ao primeiro grupo de captura. |
\1 |
Coincide com o próximo caractere que é o mesmo que o valor do primeiro grupo de capturando. |
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.
Elemento |
Descrição |
|---|---|
(?<char>\w) |
Corresponde a um caractere de palavra e atribuí-la a um grupo de captura chamado char. |
\k<char> |
Coincidir com o próximo caractere que é o mesmo que o valor da char captura de grupo. |
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.
Padrão |
Descrição |
|---|---|
(?<1>a) |
Corresponder ao caractere "a" e atribui o resultado para o grupo de capturando chamado 1. |
(?<1>\1b)* |
Ocorrência de correspondência de 0 ou 1 do grupo chamado 1 juntamente com um "b" e atribuir o resultado para o grupo de captura chamado 1. |
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:
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".
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.
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:
Padrão |
Descrição |
|---|---|
\b |
Começa a correspondência de um limite de palavra. |
(\p{Lu}{2}) |
Coincide com duas letras maiúsculas. Este é o primeiro grupo de capturando. |
(\d{2})? |
Corresponde à ocorrência de zero ou um de dois dígitos decimais. Este é o segundo grupo de capturando. |
(\p{Lu}{2}) |
Coincide com duas letras maiúsculas. Este é o terceiro grupo de capturando. |
\b |
Finalize a correspondência de um limite de palavra. |
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