Classes de Expressões Regulares
As seções a seguir descrevem as classes de expressão regular do .NET Framework.
Regex
A classe Regex representa uma expressão regular (somente leitura) imutável.Ele também contém métodos estáticos que permitem o uso de outras classes de expressão regular sem criar explicitamente as instâncias das outras classes.
O exemplo de código a seguir cria uma instância da classe Regex e define um expressão regular simples quando o objeto é inicializado.Observe o uso de uma barra invertida adicional como um caractere de escape que designa a barra invertida de caractere correspondente \s como um caractere literal na classe.
' Declare object variable of type Regex.
Dim r As Regex
' Create a Regex object and define its regular expression.
r = New Regex("\s2000")
// Declare object variable of type Regex.
Regex r;
// Create a Regex object and define its regular expression.
r = new Regex("\\s2000");
Correspondência
A classe Match representa os resultados de uma operação correspondente de expressão regular.O exemplo a seguir usa o método Match da classe Regex para retornar um objeto do tipo Match para encontrar a primeira correspondência na sequência de caracteres de entrada.O exemplo usa a propriedade Match da classe Match.Success para indicar se uma correspondência foi encontrada.
' Create a new Regex object.
Dim r As New Regex("abc")
' Find a single match in the input string.
Dim m As Match = r.Match("123abc456")
If m.Success Then
' Print out the character position where a match was found.
Console.WriteLine("Found match at position " & m.Index.ToString())
End If
' The example displays the following output:
' Found match at position 3
// Create a new Regex object.
Regex r = new Regex("abc");
// Find a single match in the string.
Match m = r.Match("123abc456");
if (m.Success)
{
// Print out the character position where a match was found.
Console.WriteLine("Found match at position " + m.Index);
}
// The example displays the following output:
// Found match at position 3
MatchCollection
A classe MatchCollection representa uma sequência de correspondências de sucesso que não apresentam sobreposição.A coleção é imutável (somente leitura) e não tem nenhum construtor público.Instâncias de MatchCollection são retornadas pelo método Regex.Matches .
O exemplo a seguir usa o método Matches da classe Regex para preencher um MatchCollection com todas as correspondências encontradas na sequência de caracteres de entrada.O exemplo copia a coleção para um matriz de sequências de caracteres que contém cada correspondência e uma matriz de inteiros que indica a posição de cada correspondência.
Dim mc As MatchCollection
Dim results As New List(Of String)
Dim matchposition As New List(Of Integer)
' Create a new Regex object and define the regular expression.
Dim r As New Regex("abc")
' Use the Matches method to find all matches in the input string.
mc = r.Matches("123abc4abcd")
' Loop through the match collection to retrieve all
' matches and positions.
For i As Integer = 0 To mc.Count - 1
' Add the match string to the string array.
results.Add(mc(i).Value)
' Record the character position where the match was found.
matchposition.Add(mc(i).Index)
Next i
' List the results.
For ctr As Integer = 0 To Results.Count - 1
Console.WriteLine("'{0}' found at position {1}.", _
results(ctr), matchposition(ctr))
Next
' The example displays the following output:
' 'abc' found at position 3.
' 'abc' found at position 7.
MatchCollection mc;
List<string> results = new List<string>();
List<int> matchposition = new List<int>();
// Create a new Regex object and define the regular expression.
Regex r = new Regex("abc");
// Use the Matches method to find all matches in the input string.
mc = r.Matches("123abc4abcd");
// Loop through the match collection to retrieve all
// matches and positions.
for (int i = 0; i < mc.Count; i++)
{
// Add the match string to the string array.
results.Add(mc[i].Value);
// Record the character position where the match was found.
matchposition.Add(mc[i].Index);
}
// List the results.
for(int ctr = 0; ctr <= results.Count - 1; ctr++)
Console.WriteLine("'{0}' found at position {1}.", results[ctr], matchposition[ctr]);
// The example displays the following output:
// 'abc' found at position 3.
// 'abc' found at position 7.
GroupCollection
A classe GroupCollection representa uma coleção dos grupos capturados e retorna o conjunto de grupos capturados em um única correspondência.A coleção é imutável (somente leitura) e não tem nenhum construtor público.Instâncias de GroupCollection são retornadas na coleção que a propriedade Match.Groups retorna.
O exemplo a seguir localiza e imprime o número de grupos capturadas por uma expressão regular.Para obter um exemplo de como extrair as capturas indivíduais em cada membro da coleção de grupo, consulte o exemplo Captura da Coleção na seção a seguir.
' Define groups "abc", "ab", and "b".
Dim r As New Regex("(a(b))c")
Dim m As Match = r.Match("abdabc")
Console.WriteLine("Number of groups found = " _
& m.Groups.Count)
' The example displays the following output:
' Number of groups found = 3
// Define groups "abc", "ab", and "b".
Regex r = new Regex("(a(b))c");
Match m = r.Match("abdabc");
Console.WriteLine("Number of groups found = " + m.Groups.Count);
// The example displays the following output:
// Number of groups found = 3
CaptureCollection
A classe CaptureCollection representa uma sequência de subsequências capturadas e retorna o conjunto de capturas feita por um único grupo captura.Um grupo de captura pode capturar mais de uma sequência de caracteres em uma única correspondência por causa de quantificadores.A propriedade Captures, um objeto da classe CaptureCollection , é fornecido como um membro das classes Match e Group para facilitar o acesso ao conjunto de subsequências capturadas.
Por exemplo, se você usar a expressão regular ((a(b))c)+ (onde o quantificador + especifica uma ou mais correspondências) para capturar correspondências a partir da sequência "abcabcabc", o CaptureCollection para cada correspondência Group de subsequências irá conter três membros.
O exemplo a seguir usa a expressão regular (Abc)+para localizar uma ou mais ocorrências da seqüência "XYZAbcAbcAbcXYZAbcAb". O exemplo ilustra o uso da propriedade Captures para retornar vários grupos de subsequências capturadas.
Dim counter As Integer
Dim m As Match
Dim cc As CaptureCollection
Dim gc As GroupCollection
' Look for groupings of "Abc".
Dim r As New Regex("(Abc)+")
' Define the string to search.
m = r.Match("XYZAbcAbcAbcXYZAbcAb")
gc = m.Groups
' Display the number of groups.
Console.WriteLine("Captured groups = " & gc.Count.ToString())
' Loop through each group.
Dim i, ii As Integer
For i = 0 To gc.Count - 1
cc = gc(i).Captures
counter = cc.Count
' Display the number of captures in this group.
Console.WriteLine("Captures count = " & counter.ToString())
' Loop through each capture in the group.
For ii = 0 To counter - 1
' Display the capture and its position.
Console.WriteLine(cc(ii).ToString() _
& " Starts at character " & cc(ii).Index.ToString())
Next ii
Next i
' The example displays the following output:
' Captured groups = 2
' Captures count = 1
' AbcAbcAbc Starts at character 3
' Captures count = 3
' Abc Starts at character 3
' Abc Starts at character 6
' Abc Starts at character 9
int counter;
Match m;
CaptureCollection cc;
GroupCollection gc;
// Look for groupings of "Abc".
Regex r = new Regex("(Abc)+");
// Define the string to search.
m = r.Match("XYZAbcAbcAbcXYZAbcAb");
gc = m.Groups;
// Display the number of groups.
Console.WriteLine("Captured groups = " + gc.Count.ToString());
// Loop through each group.
for (int i=0; i < gc.Count; i++)
{
cc = gc[i].Captures;
counter = cc.Count;
// Display the number of captures in this group.
Console.WriteLine("Captures count = " + counter.ToString());
// Loop through each capture in the group.
for (int ii = 0; ii < counter; ii++)
{
// Display the capture and its position.
Console.WriteLine(cc[ii] + " Starts at character " +
cc[ii].Index);
}
}
}
// The example displays the following output:
// Captured groups = 2
// Captures count = 1
// AbcAbcAbc Starts at character 3
// Captures count = 3
// Abc Starts at character 3
// Abc Starts at character 6
// Abc Starts at character 9
Group
A classe Group representa os resultados de um único grupo de captura.Como Group pode capturar zero, um ou mais sequências de caracteres em uma correspondência única (usando quantificadores), ele contém uma coleção de objetos Capture.Como Group herda de Capture, a última subsequência capturada pode ser acessada diretamente (a própria instância Group é equivalente ao último item da coleção retornada pela propriedade Captures).
Instâncias de Group são retornadas pela indexação do objeto GroupCollection retornado pela propriedade Groups.O indexador pode ser um número de grupo ou o nome de um grupo de captura se o agrupamento de "(?<groupname>)"construção é usado.For example, in C# code you can use Match.Groups[groupnum] or Match.Groups["groupname"], or in Visual Basiccode you can use Match.Groups(groupnum) or Match.Groups("groupname").
O exemplo de código a seguir utiliza construções de agrupamento aninhado para capturar subsequêncis em grupos.
Dim matchposition As New List(Of Integer)
Dim results As New List(Of String)
' Define substrings abc, ab, b.
Dim r As New Regex("(a(b))c")
Dim m As Match = r.Match("abdabc")
Dim i As Integer = 0
While Not (m.Groups(i).Value = "")
' Add groups to string array.
results.Add(m.Groups(i).Value)
' Record character position.
matchposition.Add(m.Groups(i).Index)
i += 1
End While
' Display the capture groups.
For ctr As Integer = 0 to results.Count - 1
Console.WriteLine("{0} at position {1}", _
results(ctr), matchposition(ctr))
Next
' The example displays the following output:
' abc at position 3
' ab at position 3
' b at position 4
List<int> matchposition = new List<int>();
List<string> results = new List<string>();
// Define substrings abc, ab, b.
Regex r = new Regex("(a(b))c");
Match m = r.Match("abdabc");
for (int i = 0; m.Groups[i].Value != ""; i++)
{
// Add groups to string array.
results.Add(m.Groups[i].Value);
// Record character position.
matchposition.Add(m.Groups[i].Index);
}
// Display the capture groups.
for (int ctr = 0; ctr < results.Count; ctr++)
Console.WriteLine("{0} at position {1}",
results[ctr], matchposition[ctr]);
// The example displays the following output:
// abc at position 3
// ab at position 3
// b at position 4
O exemplo de código a seguir utiliza construções de agrupamento nomeado para capturar subsequências de uma sequência de caracteres que contém dados em um formato "DATANAME:VALUE" que a expressão regular divide em dois-pontos (:).
Dim r As New Regex("^(?<name>\w+):(?<value>\w+)")
Dim m As Match = r.Match("Section1:119900")
Console.WriteLine(m.Groups("name").Value)
Console.WriteLine(m.Groups("value").Value)
' The example displays the following output:
' Section1
' 119900
Regex r = new Regex("^(?<name>\\w+):(?<value>\\w+)");
Match m = r.Match("Section1:119900");
Console.WriteLine(m.Groups["name"].Value);
Console.WriteLine(m.Groups["value"].Value);
// The example displays the following output:
// Section1
// 119900
Capture
A classe Capture contém os resultados de uma única captura de subexpressão.
O seguinte exemplo varre uma coleção Group, extrai a coleção Capture de cada membro do Group e atribui as variáveis posn e Length para a posição do caractere na sequência original de caracteres onde cada sequência foi encontrada e o comprimento de cada sequência de caracteres, respectivamente.
Dim r As Regex
Dim m As Match
Dim cc As CaptureCollection
Dim posn, length As Integer
r = New Regex("(abc)+")
m = r.Match("bcabcabc")
Dim i, j As Integer
i = 0
Do While m.Groups(i).Value <> ""
Console.WriteLine(m.Groups(i).Value)
' Grab the Collection for Group(i).
cc = m.Groups(i).Captures
For j = 0 To cc.Count - 1
Console.WriteLine(" Capture at position {0} for {1} characters.", _
cc(j).Length, cc(j).Index)
' Position of Capture object.
posn = cc(j).Index
' Length of Capture object.
length = cc(j).Length
Next j
i += 1
Loop
' The example displays the following output:
' abcabc
' Capture at position 6 for 2 characters.
' abc
' Capture at position 3 for 2 characters.
' Capture at position 3 for 5 characters.
Regex r;
Match m;
CaptureCollection cc;
int posn, length;
r = new Regex("(abc)+");
m = r.Match("bcabcabc");
for (int i=0; m.Groups[i].Value != ""; i++)
{
Console.WriteLine(m.Groups[i].Value);
// Capture the Collection for Group(i).
cc = m.Groups[i].Captures;
for (int j = 0; j < cc.Count; j++)
{
Console.WriteLine(" Capture at position {0} for {1} characters.",
cc[j].Length, cc[j].Index);
// Position of Capture object.
posn = cc[j].Index;
// Length of Capture object.
length = cc[j].Length;
}
}
// The example displays the following output:
// abcabc
// Capture at position 6 for 2 characters.
// abc
// Capture at position 3 for 2 characters.
// Capture at position 3 for 5 characters.
Consulte também
Referência
System.Text.RegularExpressions