O modelo de objeto de expressão regular
Este tópico descreve o modelo de objeto usado no trabalho com expressões regulares do .NET. Contém as seguintes secções:
O mecanismo de expressão regular
O mecanismo de expressão regular no .NET é representado pela Regex classe. O mecanismo de expressão regular é responsável por analisar e compilar uma expressão regular e por executar operações que correspondam ao padrão de expressão regular com uma cadeia de caracteres de entrada. O mecanismo é o componente central no modelo de objeto de expressão regular do .NET.
Você pode usar o mecanismo de expressão regular de duas maneiras:
Chamando os métodos estáticos da Regex classe. Os parâmetros do método incluem a cadeia de caracteres de entrada e o padrão de expressão regular. O mecanismo de expressão regular armazena em cache expressões regulares que são usadas em chamadas de método estático, portanto, chamadas repetidas para métodos de expressão regular estática que usam a mesma expressão regular oferecem um desempenho relativamente bom.
Instanciando um Regex objeto, passando uma expressão regular para o construtor de classe. Nesse caso, o objeto é imutável (somente leitura) e representa um mecanismo de expressão regular que está firmemente acoplado Regex a uma única expressão regular. Como as expressões regulares usadas pelas Regex instâncias não são armazenadas em cache, você não deve instanciar um Regex objeto várias vezes com a mesma expressão regular.
Você pode chamar os métodos da Regex classe para executar as seguintes operações:
Determine se uma cadeia de caracteres corresponde a um padrão de expressão regular.
Extraia uma única correspondência ou a primeira correspondência.
Extraia todas as correspondências.
Substitua uma subcadeia de caracteres correspondente.
Divida uma única cadeia de caracteres em uma matriz de cadeias de caracteres.
Essas operações são descritas nas seções a seguir.
Correspondendo a um padrão de expressão regular
O Regex.IsMatch método retorna true se a cadeia de caracteres corresponde ao padrão ou false se não corresponder. O IsMatch método é frequentemente usado para validar a entrada de cadeia de caracteres. Por exemplo, o código a seguir garante que uma cadeia de caracteres corresponda a um número de segurança social válido nos Estados Unidos.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string[] values = { "111-22-3333", "111-2-3333"};
string pattern = @"^\d{3}-\d{2}-\d{4}$";
foreach (string value in values) {
if (Regex.IsMatch(value, pattern))
Console.WriteLine("{0} is a valid SSN.", value);
else
Console.WriteLine("{0}: Invalid", value);
}
}
}
// The example displays the following output:
// 111-22-3333 is a valid SSN.
// 111-2-3333: Invalid
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim values() As String = {"111-22-3333", "111-2-3333"}
Dim pattern As String = "^\d{3}-\d{2}-\d{4}$"
For Each value As String In values
If Regex.IsMatch(value, pattern) Then
Console.WriteLine("{0} is a valid SSN.", value)
Else
Console.WriteLine("{0}: Invalid", value)
End If
Next
End Sub
End Module
' The example displays the following output:
' 111-22-3333 is a valid SSN.
' 111-2-3333: Invalid
O padrão ^\d{3}-\d{2}-\d{4}$ de expressão regular é interpretado como mostrado na tabela a seguir.
| Padrão | Description |
|---|---|
^ |
Corresponda ao início da cadeia de caracteres de entrada. |
\d{3} |
Corresponder a três dígitos decimais. |
- |
Corresponder a um hífen. |
\d{2} |
Corresponder a dois dígitos decimais. |
- |
Corresponder a um hífen. |
\d{4} |
Corresponder a quatro dígitos decimais. |
$ |
Corresponder ao final da cadeia de caracteres de entrada. |
Extraindo uma única partida ou a primeira partida
O Regex.Match método retorna um Match objeto que contém informações sobre a primeira substring que corresponde a um padrão de expressão regular. Se a Match.Success propriedade retornar true, indicando que uma correspondência foi encontrada, você poderá recuperar informações sobre correspondências subsequentes chamando o Match.NextMatch método. Essas chamadas de método podem continuar até que a Match.Success propriedade retorne false. Por exemplo, o código a seguir usa o Regex.Match(String, String) método para localizar a primeira ocorrência de uma palavra duplicada em uma cadeia de caracteres. Em seguida, ele chama o Match.NextMatch método para localizar quaisquer ocorrências adicionais. O exemplo examina a Match.Success propriedade após cada chamada de método para determinar se a correspondência atual foi bem-sucedida e se uma chamada para o Match.NextMatch método deve seguir.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "This is a a farm that that raises dairy cattle.";
string pattern = @"\b(\w+)\W+(\1)\b";
Match match = Regex.Match(input, pattern);
while (match.Success)
{
Console.WriteLine("Duplicate '{0}' found at position {1}.",
match.Groups[1].Value, match.Groups[2].Index);
match = match.NextMatch();
}
}
}
// The example displays the following output:
// Duplicate 'a' found at position 10.
// Duplicate 'that' found at position 22.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "This is a a farm that that raises dairy cattle."
Dim pattern As String = "\b(\w+)\W+(\1)\b"
Dim match As Match = Regex.Match(input, pattern)
Do While match.Success
Console.WriteLine("Duplicate '{0}' found at position {1}.", _
match.Groups(1).Value, match.Groups(2).Index)
match = match.NextMatch()
Loop
End Sub
End Module
' The example displays the following output:
' Duplicate 'a' found at position 10.
' Duplicate 'that' found at position 22.
O padrão \b(\w+)\W+(\1)\b de expressão regular é interpretado como mostrado na tabela a seguir.
| Padrão | Description |
|---|---|
\b |
Comece a partida em um limite de palavras. |
(\w+) |
Corresponder a um ou mais caracteres de palavra. Este é o primeiro grupo de captura. |
\W+ |
Corresponder a um ou mais caracteres que não sejam palavras. |
(\1) |
Corresponder à primeira cadeia de caracteres capturada. Este é o segundo grupo de captura. |
\b |
Termine a partida com um limite de palavras. |
Extraindo todas as correspondências
O Regex.Matches método retorna um MatchCollection objeto que contém informações sobre todas as correspondências que o mecanismo de expressão regular encontrou na cadeia de caracteres de entrada. Por exemplo, o exemplo anterior pode ser reescrito para chamar o Matches método em vez dos Match métodos e NextMatch .
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "This is a a farm that that raises dairy cattle.";
string pattern = @"\b(\w+)\W+(\1)\b";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine("Duplicate '{0}' found at position {1}.",
match.Groups[1].Value, match.Groups[2].Index);
}
}
// The example displays the following output:
// Duplicate 'a' found at position 10.
// Duplicate 'that' found at position 22.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "This is a a farm that that raises dairy cattle."
Dim pattern As String = "\b(\w+)\W+(\1)\b"
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("Duplicate '{0}' found at position {1}.", _
match.Groups(1).Value, match.Groups(2).Index)
Next
End Sub
End Module
' The example displays the following output:
' Duplicate 'a' found at position 10.
' Duplicate 'that' found at position 22.
Substituindo uma substring correspondente
O Regex.Replace método substitui cada substring que corresponde ao padrão de expressão regular por uma string especificada ou padrão de expressão regular e retorna toda a string de entrada com substituições. Por exemplo, o código a seguir adiciona um símbolo de moeda dos EUA antes de um número decimal em uma cadeia de caracteres.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b\d+\.\d{2}\b";
string replacement = "$$$&";
string input = "Total Cost: 103.64";
Console.WriteLine(Regex.Replace(input, pattern, replacement));
}
}
// The example displays the following output:
// Total Cost: $103.64
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b\d+\.\d{2}\b"
Dim replacement As String = "$$$&"
Dim input As String = "Total Cost: 103.64"
Console.WriteLine(Regex.Replace(input, pattern, replacement))
End Sub
End Module
' The example displays the following output:
' Total Cost: $103.64
O padrão \b\d+\.\d{2}\b de expressão regular é interpretado como mostrado na tabela a seguir.
| Padrão | Description |
|---|---|
\b |
Comece a partida com um limite de palavras. |
\d+ |
Corresponder a um ou mais dígitos decimais. |
\. |
Corresponda a um ponto. |
\d{2} |
Corresponder a dois dígitos decimais. |
\b |
Termine a partida com um limite de palavras. |
O padrão $$$& de substituição é interpretado como mostrado na tabela a seguir.
| Padrão | String de substituição |
|---|---|
$$ |
O caractere cifrão ($). |
$& |
Toda a subcadeia de caracteres correspondente. |
Dividindo uma única cadeia de caracteres em uma matriz de cadeias de caracteres
O Regex.Split método divide a cadeia de caracteres de entrada nas posições definidas por uma correspondência de expressão regular. Por exemplo, o código a seguir coloca os itens em uma lista numerada em uma matriz de cadeia de caracteres.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "1. Eggs 2. Bread 3. Milk 4. Coffee 5. Tea";
string pattern = @"\b\d{1,2}\.\s";
foreach (string item in Regex.Split(input, pattern))
{
if (! String.IsNullOrEmpty(item))
Console.WriteLine(item);
}
}
}
// The example displays the following output:
// Eggs
// Bread
// Milk
// Coffee
// Tea
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "1. Eggs 2. Bread 3. Milk 4. Coffee 5. Tea"
Dim pattern As String = "\b\d{1,2}\.\s"
For Each item As String In Regex.Split(input, pattern)
If Not String.IsNullOrEmpty(item) Then
Console.WriteLine(item)
End If
Next
End Sub
End Module
' The example displays the following output:
' Eggs
' Bread
' Milk
' Coffee
' Tea
O padrão \b\d{1,2}\.\s de expressão regular é interpretado como mostrado na tabela a seguir.
| Padrão | Description |
|---|---|
\b |
Comece a partida com um limite de palavras. |
\d{1,2} |
Corresponder a um ou dois dígitos decimais. |
\. |
Corresponda a um ponto. |
\s |
Corresponder a um caractere de espaço em branco. |
Os objetos MatchCollection e Match
Os métodos Regex retornam dois objetos que fazem parte do modelo de objeto de expressão regular: o MatchCollection objeto e o Match objeto.
A Coleção Match
O Regex.Matches método retorna um MatchCollection objeto que contém Match objetos que representam todas as correspondências que o mecanismo de expressão regular encontrou, na ordem em que ocorrem na cadeia de caracteres de entrada. Se não houver correspondências, o método retornará um MatchCollection objeto sem membros. A MatchCollection.Item[] propriedade permite acessar membros individuais da coleção por índice, de zero a um a menos do que o valor da MatchCollection.Count propriedade. Item[] é o indexador da coleção (em C#) e a propriedade padrão (no Visual Basic).
Por padrão, a chamada para o método usa avaliação lenta Regex.Matches para preencher o MatchCollection objeto. O acesso a propriedades que exigem uma coleção totalmente preenchida, como as MatchCollection.Count propriedades e MatchCollection.Item[] , pode envolver uma penalidade de desempenho. Como resultado, recomendamos que você acesse a coleção usando o IEnumerator objeto retornado pelo MatchCollection.GetEnumerator método. Linguagens individuais fornecem construções, como For Each em Visual Basic e foreach em C#, que envolvem a interface da IEnumerator coleção.
O exemplo a seguir usa o Regex.Matches(String) método para preencher um MatchCollection objeto com todas as correspondências encontradas em uma cadeia de caracteres de entrada. O exemplo enumera a coleção, copia as correspondências para uma matriz de cadeia de caracteres e registra as posições de caracteres em uma matriz inteira.
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
MatchCollection matches;
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.
matches = r.Matches("123abc4abcd");
// Enumerate the collection to retrieve all matches and positions.
foreach (Match match in matches)
{
// Add the match string to the string array.
results.Add(match.Value);
// Record the character position where the match was found.
matchposition.Add(match.Index);
}
// List the results.
for (int ctr = 0; ctr < results.Count; 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.
Imports System.Collections.Generic
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim matches 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.
matches = r.Matches("123abc4abcd")
' Enumerate the collection to retrieve all matches and positions.
For Each match As Match In matches
' Add the match string to the string array.
results.Add(match.Value)
' Record the character position where the match was found.
matchposition.Add(match.Index)
Next
' List the results.
For ctr As Integer = 0 To results.Count - 1
Console.WriteLine("'{0}' found at position {1}.", _
results(ctr), matchposition(ctr))
Next
End Sub
End Module
' The example displays the following output:
' 'abc' found at position 3.
' 'abc' found at position 7.
O jogo
A Match classe representa o resultado de uma única correspondência de expressão regular. Você pode acessar Match objetos de duas maneiras:
Recuperando-os do MatchCollection objeto que é retornado pelo Regex.Matches método. Para recuperar objetos individuais Match , itere a coleção usando uma
foreachconstrução (em C#) ouFor Each...Next(em Visual Basic) ou use a MatchCollection.Item[] propriedade para recuperar um objeto específico Match por índice ou por nome. Você também pode recuperar objetos individuais Match da coleção iterando a coleção por índice, de zero a um a menos que o número de objetos na coleção. No entanto, este método não aproveita a avaliação preguiçosa, pois acede ao MatchCollection.Count imóvel.O exemplo a seguir recupera objetos individuais Match de um MatchCollection objeto iterando a coleção usando a
foreachconstrução ouFor Each...NextA expressão regular simplesmente corresponde à string "abc" na string de entrada.using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = "abc"; string input = "abc123abc456abc789"; foreach (Match match in Regex.Matches(input, pattern)) Console.WriteLine("{0} found at position {1}.", match.Value, match.Index); } } // The example displays the following output: // abc found at position 0. // abc found at position 6. // abc found at position 12.Imports System.Text.RegularExpressions Module Example Public Sub Main() Dim pattern As String = "abc" Dim input As String = "abc123abc456abc789" For Each match As Match In Regex.Matches(input, pattern) Console.WriteLine("{0} found at position {1}.", _ match.Value, match.Index) Next End Sub End Module ' The example displays the following output: ' abc found at position 0. ' abc found at position 6. ' abc found at position 12.Chamando o Regex.Match método, que retorna um Match objeto que representa a primeira correspondência em uma cadeia de caracteres ou uma parte de uma cadeia de caracteres. Você pode determinar se a correspondência foi encontrada recuperando o valor da
Match.Successpropriedade. Para recuperar Match objetos que representam correspondências subsequentes, chame o Match.NextMatch método repetidamente, até que aSuccesspropriedade do objeto retornado Match sejafalse.O exemplo a seguir usa os Regex.Match(String, String) métodos e Match.NextMatch para corresponder à cadeia de caracteres "abc" na cadeia de caracteres de entrada.
using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = "abc"; string input = "abc123abc456abc789"; Match match = Regex.Match(input, pattern); while (match.Success) { Console.WriteLine("{0} found at position {1}.", match.Value, match.Index); match = match.NextMatch(); } } } // The example displays the following output: // abc found at position 0. // abc found at position 6. // abc found at position 12.Imports System.Text.RegularExpressions Module Example Public Sub Main() Dim pattern As String = "abc" Dim input As String = "abc123abc456abc789" Dim match As Match = Regex.Match(input, pattern) Do While match.Success Console.WriteLine("{0} found at position {1}.", _ match.Value, match.Index) match = match.NextMatch() Loop End Sub End Module ' The example displays the following output: ' abc found at position 0. ' abc found at position 6. ' abc found at position 12.
Duas propriedades da Match classe retornam objetos de coleção:
A Match.Groups propriedade retorna um GroupCollection objeto que contém informações sobre as substrings que correspondem à captura de grupos no padrão de expressão regular.
A
Match.Capturespropriedade retorna um CaptureCollection objeto que é de uso limitado. A coleção não é preenchida para um Match objeto cujaSuccesspropriedade éfalse. Caso contrário, ele contém um único Capture objeto que tem as mesmas informações que o Match objeto.
Para obter mais informações sobre esses objetos, consulte as seções The Group Collection e The Capture Collection mais adiante neste tópico.
Duas propriedades adicionais da Match classe fornecem informações sobre a correspondência. A Match.Value propriedade retorna a substring na cadeia de caracteres de entrada que corresponde ao padrão de expressão regular. A Match.Index propriedade retorna a posição inicial baseada em zero da cadeia de caracteres correspondente na cadeia de caracteres de entrada.
A Match classe também tem dois métodos de correspondência de padrões:
O Match.NextMatch método localiza a correspondência após a correspondência representada pelo objeto atual Match e retorna um Match objeto que representa essa correspondência.
O Match.Result método executa uma operação de substituição especificada na cadeia de caracteres correspondente e retorna o resultado.
O exemplo a seguir usa o Match.Result método para preceder um símbolo $ e um espaço antes de cada número que inclui dois dígitos fracionários.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b\d+(,\d{3})*\.\d{2}\b";
string input = "16.32\n194.03\n1,903,672.08";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(match.Result("$$ $&"));
}
}
// The example displays the following output:
// $ 16.32
// $ 194.03
// $ 1,903,672.08
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b\d+(,\d{3})*\.\d{2}\b"
Dim input As String = "16.32" + vbCrLf + "194.03" + vbCrLf + "1,903,672.08"
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(match.Result("$$ $&"))
Next
End Sub
End Module
' The example displays the following output:
' $ 16.32
' $ 194.03
' $ 1,903,672.08
O padrão \b\d+(,\d{3})*\.\d{2}\b de expressão regular é definido conforme mostrado na tabela a seguir.
| Padrão | Description |
|---|---|
\b |
Comece a partida com um limite de palavras. |
\d+ |
Corresponder a um ou mais dígitos decimais. |
(,\d{3})* |
Corresponder a zero ou mais ocorrências de uma vírgula seguida de três dígitos decimais. |
\. |
Corresponder ao caractere de ponto decimal. |
\d{2} |
Corresponder a dois dígitos decimais. |
\b |
Termine a partida com um limite de palavras. |
O padrão $$ $& de substituição indica que a substring correspondente deve ser substituída por um símbolo de cifrão ($) (o $$ padrão), um espaço e o valor da correspondência (o $& padrão).
A Coleção do Grupo
A Match.Groups propriedade retorna um GroupCollection objeto que contém Group objetos que representam grupos capturados em uma única correspondência. O primeiro Group objeto da coleção (no índice 0) representa toda a correspondência. Cada objeto a seguir representa os resultados de um único grupo de captura.
Você pode recuperar objetos individuais Group na coleção usando a GroupCollection.Item[] propriedade. Você pode recuperar grupos sem nome por sua posição ordinal na coleção e recuperar grupos nomeados por nome ou por posição ordinal. As capturas sem nome aparecem primeiro na coleção e são indexadas da esquerda para a direita na ordem em que aparecem no padrão de expressão regular. As capturas nomeadas são indexadas após capturas sem nome, da esquerda para a direita na ordem em que aparecem no padrão de expressão regular. Para determinar quais grupos numerados estão disponíveis na coleção retornada para um determinado método de correspondência de expressão regular, você pode chamar o método de instância Regex.GetGroupNumbers . Para determinar quais grupos nomeados estão disponíveis na coleção, você pode chamar o método de instância Regex.GetGroupNames . Ambos os métodos são particularmente úteis em rotinas de uso geral que analisam as correspondências encontradas por qualquer expressão regular.
A GroupCollection.Item[] propriedade é o indexador da coleção em C# e a propriedade padrão do objeto de coleção no Visual Basic. Isso significa que objetos individuais Group podem ser acessados por índice (ou por nome, no caso de grupos nomeados) da seguinte maneira:
Group group = match.Groups[ctr];
Dim group As Group = match.Groups(ctr)
O exemplo a seguir define uma expressão regular que usa construções de agrupamento para capturar o mês, dia e ano de uma data.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b(\w+)\s(\d{1,2}),\s(\d{4})\b";
string input = "Born: July 28, 1989";
Match match = Regex.Match(input, pattern);
if (match.Success)
for (int ctr = 0; ctr < match.Groups.Count; ctr++)
Console.WriteLine("Group {0}: {1}", ctr, match.Groups[ctr].Value);
}
}
// The example displays the following output:
// Group 0: July 28, 1989
// Group 1: July
// Group 2: 28
// Group 3: 1989
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b(\w+)\s(\d{1,2}),\s(\d{4})\b"
Dim input As String = "Born: July 28, 1989"
Dim match As Match = Regex.Match(input, pattern)
If match.Success Then
For ctr As Integer = 0 To match.Groups.Count - 1
Console.WriteLine("Group {0}: {1}", ctr, match.Groups(ctr).Value)
Next
End If
End Sub
End Module
' The example displays the following output:
' Group 0: July 28, 1989
' Group 1: July
' Group 2: 28
' Group 3: 1989
O padrão \b(\w+)\s(\d{1,2}),\s(\d{4})\b de expressão regular é definido conforme mostrado na tabela a seguir.
| Padrão | Description |
|---|---|
\b |
Comece a partida com um limite de palavras. |
(\w+) |
Corresponder a um ou mais caracteres de palavra. Este é o primeiro grupo de captura. |
\s |
Corresponder a um caractere de espaço em branco. |
(\d{1,2}) |
Corresponder a um ou dois dígitos decimais. Este é o segundo grupo de captura. |
, |
Corresponda a uma vírgula. |
\s |
Corresponder a um caractere de espaço em branco. |
(\d{4}) |
Corresponder a quatro dígitos decimais. Este é o terceiro grupo de captura. |
\b |
Termine a partida com um limite de palavras. |
O Grupo Capturado
A Group classe representa o resultado de um único grupo de captura. Os objetos de grupo que representam os grupos de captura definidos em uma expressão regular são retornados pela Item[] propriedade do GroupCollection objeto retornado pela Match.Groups propriedade. A Item[] propriedade é o indexador (em C#) e a propriedade padrão (em Visual Basic) da Group classe. Você também pode recuperar membros individuais iterando a coleção usando a foreach construção or For Each . Para um exemplo, consulte a seção anterior.
O exemplo a seguir usa construções de agrupamento aninhadas para capturar substrings em grupos. O padrão (a(b))c de expressão regular corresponde à cadeia de caracteres "abc". Ele atribui a substring "ab" ao primeiro grupo de captura, e a substring "b" ao segundo grupo de captura.
var matchposition = new List<int>();
var results = new List<string>();
// Define substrings abc, ab, b.
var 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
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
O exemplo a seguir usa construções de agrupamento nomeadas para capturar substrings de uma cadeia de caracteres que contém dados no formato "DATANAME:VALUE", que a expressão regular divide nos dois pontos (:).
var 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
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
O padrão ^(?<name>\w+):(?<value>\w+) de expressão regular é definido conforme mostrado na tabela a seguir.
| Padrão | Description |
|---|---|
^ |
Comece a correspondência no início da cadeia de caracteres de entrada. |
(?<name>\w+) |
Corresponder a um ou mais caracteres de palavra. O nome desse grupo de captura é name. |
: |
Corresponda a dois pontos. |
(?<value>\w+) |
Corresponder a um ou mais caracteres de palavra. O nome desse grupo de captura é value. |
As propriedades da Group classe fornecem informações sobre o grupo capturado: A Group.Value propriedade contém a substring capturada, a Group.Index propriedade indica a posição inicial do grupo capturado no texto de entrada, a Group.Length propriedade contém o comprimento do texto capturado e a Group.Success propriedade indica se uma substring correspondia ao padrão definido pelo grupo de captura.
A aplicação de quantificadores a um grupo (para obter mais informações, consulte Quantificadores) modifica a relação de uma captura por grupo de captura de duas maneiras:
Se o
*quantificador ou*?(que especifica zero ou mais correspondências) for aplicado a um grupo, um grupo de captura pode não ter uma correspondência na cadeia de caracteres de entrada. Quando não há texto capturado, as propriedades do Group objeto são definidas conforme mostrado na tabela a seguir.Propriedade do grupo Value SuccessfalseValueString.Empty Length0 O exemplo a seguir fornece uma ilustração. No padrão
aaa(bbb)*cccde expressão regular, o primeiro grupo de captura (a substring "bbb") pode ser correspondido zero ou mais vezes. Como a cadeia de caracteres de entrada "aaaccc" corresponde ao padrão, o grupo de captura não tem uma correspondência.using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = "aaa(bbb)*ccc"; string input = "aaaccc"; Match match = Regex.Match(input, pattern); Console.WriteLine("Match value: {0}", match.Value); if (match.Groups[1].Success) Console.WriteLine("Group 1 value: {0}", match.Groups[1].Value); else Console.WriteLine("The first capturing group has no match."); } } // The example displays the following output: // Match value: aaaccc // The first capturing group has no match.Imports System.Text.RegularExpressions Module Example Public Sub Main() Dim pattern As String = "aaa(bbb)*ccc" Dim input As String = "aaaccc" Dim match As Match = Regex.Match(input, pattern) Console.WriteLine("Match value: {0}", match.Value) If match.Groups(1).Success Then Console.WriteLine("Group 1 value: {0}", match.Groups(1).Value) Else Console.WriteLine("The first capturing group has no match.") End If End Sub End Module ' The example displays the following output: ' Match value: aaaccc ' The first capturing group has no match.Os quantificadores podem corresponder a várias ocorrências de um padrão definido por um grupo de captura. Nesse caso, as
Valuepropriedades eLengthde um Group objeto contêm informações apenas sobre a última subcadeia capturada. Por exemplo, a expressão regular a seguir corresponde a uma única frase que termina em um ponto. Ele usa duas construções de agrupamento: A primeira captura palavras individuais juntamente com um caractere de espaço em branco; o segundo capta palavras individuais. Como mostra a saída do exemplo, embora a expressão regular consiga capturar uma frase inteira, o segundo grupo de captura captura apenas a última palavra.using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = @"\b((\w+)\s?)+\."; string input = "This is a sentence. This is another sentence."; Match match = Regex.Match(input, pattern); if (match.Success) { Console.WriteLine("Match: " + match.Value); Console.WriteLine("Group 2: " + match.Groups[2].Value); } } } // The example displays the following output: // Match: This is a sentence. // Group 2: sentenceImports System.Text.RegularExpressions Module Example Public Sub Main() Dim pattern As String = "\b((\w+)\s?)+\." Dim input As String = "This is a sentence. This is another sentence." Dim match As Match = Regex.Match(input, pattern) If match.Success Then Console.WriteLine("Match: " + match.Value) Console.WriteLine("Group 2: " + match.Groups(2).Value) End If End Sub End Module ' The example displays the following output: ' Match: This is a sentence. ' Group 2: sentence
A Coleção Capture
O Group objeto contém informações apenas sobre a última captura. No entanto, todo o conjunto de capturas feitas por um grupo de captura ainda está disponível a partir do CaptureCollection objeto que é retornado pela Group.Captures propriedade. Cada membro da coleção é um Capture objeto que representa uma captura feita por esse grupo de captura, na ordem em que foram capturados (e, portanto, na ordem em que as cadeias de caracteres capturadas foram combinadas da esquerda para a direita na cadeia de entrada). Você pode recuperar objetos individuais Capture da coleção de duas maneiras:
Iterando através da coleção usando uma construção como
foreach(em C#) ouFor Each(em Visual Basic).Usando a CaptureCollection.Item[] propriedade para recuperar um objeto específico por índice. A Item[] propriedade é a propriedade padrão do CaptureCollection objeto (em Visual Basic) ou indexador (em C#).
Se um quantificador não for aplicado a um grupo de captura, o CaptureCollection objeto conterá um único Capture objeto que é de pouco interesse, porque fornece informações sobre a mesma correspondência que seu Group objeto. Se um quantificador for aplicado a um grupo de captura, o CaptureCollection objeto conterá todas as capturas feitas pelo grupo de captura, e o último membro da coleção representará a mesma captura que o Group objeto.
Por exemplo, se você usar o padrão ((a(b))c)+ de expressão regular (onde o quantificador + especifica uma ou mais correspondências) para capturar correspondências da cadeia de caracteres "abcabcabc", o CaptureCollection objeto para cada Group objeto contém três membros.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = "((a(b))c)+";
string input = "abcabcabc";
Match match = Regex.Match(input, pattern);
if (match.Success)
{
Console.WriteLine("Match: '{0}' at position {1}",
match.Value, match.Index);
GroupCollection groups = match.Groups;
for (int ctr = 0; ctr < groups.Count; ctr++) {
Console.WriteLine(" Group {0}: '{1}' at position {2}",
ctr, groups[ctr].Value, groups[ctr].Index);
CaptureCollection captures = groups[ctr].Captures;
for (int ctr2 = 0; ctr2 < captures.Count; ctr2++) {
Console.WriteLine(" Capture {0}: '{1}' at position {2}",
ctr2, captures[ctr2].Value, captures[ctr2].Index);
}
}
}
}
}
// The example displays the following output:
// Match: 'abcabcabc' at position 0
// Group 0: 'abcabcabc' at position 0
// Capture 0: 'abcabcabc' at position 0
// Group 1: 'abc' at position 6
// Capture 0: 'abc' at position 0
// Capture 1: 'abc' at position 3
// Capture 2: 'abc' at position 6
// Group 2: 'ab' at position 6
// Capture 0: 'ab' at position 0
// Capture 1: 'ab' at position 3
// Capture 2: 'ab' at position 6
// Group 3: 'b' at position 7
// Capture 0: 'b' at position 1
// Capture 1: 'b' at position 4
// Capture 2: 'b' at position 7
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "((a(b))c)+"
Dim input As STring = "abcabcabc"
Dim match As Match = Regex.Match(input, pattern)
If match.Success Then
Console.WriteLine("Match: '{0}' at position {1}", _
match.Value, match.Index)
Dim groups As GroupCollection = match.Groups
For ctr As Integer = 0 To groups.Count - 1
Console.WriteLine(" Group {0}: '{1}' at position {2}", _
ctr, groups(ctr).Value, groups(ctr).Index)
Dim captures As CaptureCollection = groups(ctr).Captures
For ctr2 As Integer = 0 To captures.Count - 1
Console.WriteLine(" Capture {0}: '{1}' at position {2}", _
ctr2, captures(ctr2).Value, captures(ctr2).Index)
Next
Next
End If
End Sub
End Module
' The example displays the following output:
' Match: 'abcabcabc' at position 0
' Group 0: 'abcabcabc' at position 0
' Capture 0: 'abcabcabc' at position 0
' Group 1: 'abc' at position 6
' Capture 0: 'abc' at position 0
' Capture 1: 'abc' at position 3
' Capture 2: 'abc' at position 6
' Group 2: 'ab' at position 6
' Capture 0: 'ab' at position 0
' Capture 1: 'ab' at position 3
' Capture 2: 'ab' at position 6
' Group 3: 'b' at position 7
' Capture 0: 'b' at position 1
' Capture 1: 'b' at position 4
' Capture 2: 'b' at position 7
O exemplo a seguir usa a expressão (Abc)+ regular para localizar uma ou mais execuções consecutivas da cadeia de caracteres "Abc" na cadeia de caracteres "XYZAbcAbcAbcXYZAbcAb". O exemplo ilustra o Group.Captures uso da propriedade para retornar vários grupos de substrings capturadas.
int counter;
Match m;
CaptureCollection cc;
GroupCollection gc;
// Look for groupings of "Abc".
var 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
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
A Captura Individual
A Capture classe contém os resultados de uma única captura de subexpressão. A Capture.Value propriedade contém o texto correspondente e indica Capture.Index a posição baseada em zero na cadeia de caracteres de entrada na qual a subcadeia de caracteres correspondente começa.
O exemplo a seguir analisa uma cadeia de caracteres de entrada para a temperatura de cidades selecionadas. Uma vírgula (",") é usada para separar uma cidade e sua temperatura, e um ponto-e-vírgula (";") é usado para separar os dados de cada cidade. A cadeia de caracteres de entrada inteira representa uma única correspondência. No padrão ((\w+(\s\w+)*),(\d+);)+de expressão regular , que é usado para analisar a cadeia de caracteres, o nome da cidade é atribuído ao segundo grupo de captura e a temperatura é atribuída ao quarto grupo de captura.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "Miami,78;Chicago,62;New York,67;San Francisco,59;Seattle,58;";
string pattern = @"((\w+(\s\w+)*),(\d+);)+";
Match match = Regex.Match(input, pattern);
if (match.Success)
{
Console.WriteLine("Current temperatures:");
for (int ctr = 0; ctr < match.Groups[2].Captures.Count; ctr++)
Console.WriteLine("{0,-20} {1,3}", match.Groups[2].Captures[ctr].Value,
match.Groups[4].Captures[ctr].Value);
}
}
}
// The example displays the following output:
// Current temperatures:
// Miami 78
// Chicago 62
// New York 67
// San Francisco 59
// Seattle 58
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "Miami,78;Chicago,62;New York,67;San Francisco,59;Seattle,58;"
Dim pattern As String = "((\w+(\s\w+)*),(\d+);)+"
Dim match As Match = Regex.Match(input, pattern)
If match.Success Then
Console.WriteLine("Current temperatures:")
For ctr As Integer = 0 To match.Groups(2).Captures.Count - 1
Console.WriteLine("{0,-20} {1,3}", match.Groups(2).Captures(ctr).Value, _
match.Groups(4).Captures(ctr).Value)
Next
End If
End Sub
End Module
' The example displays the following output:
' Current temperatures:
' Miami 78
' Chicago 62
' New York 67
' San Francisco 59
' Seattle 58
A expressão regular é definida conforme mostrado na tabela a seguir.
| Padrão | Description |
|---|---|
\w+ |
Corresponder a um ou mais caracteres de palavra. |
(\s\w+)* |
Corresponder a zero ou mais ocorrências de um caractere de espaço em branco seguido por um ou mais caracteres de palavra. Este padrão corresponde a nomes de cidades com várias palavras. Este é o terceiro grupo de captura. |
(\w+(\s\w+)*) |
Corresponder a um ou mais caracteres de palavra seguidos por zero ou mais ocorrências de um caractere de espaço em branco e um ou mais caracteres de palavra. Este é o segundo grupo de captura. |
, |
Corresponda a uma vírgula. |
(\d+) |
Corresponder a um ou mais dígitos. Este é o quarto grupo de captura. |
; |
Corresponda a um ponto-e-vírgula. |
((\w+(\s\w+)*),(\d+);)+ |
Corresponder ao padrão de uma palavra seguida por quaisquer palavras adicionais seguidas por uma vírgula, um ou mais dígitos e um ponto-e-vírgula, uma ou mais vezes. Este é o primeiro grupo de captura. |
Consulte também
Comentários
Brevemente: ao longo de 2024, vamos descontinuar progressivamente o GitHub Issues como mecanismo de feedback para conteúdos e substituí-lo por um novo sistema de feedback. Para obter mais informações, veja: https://aka.ms/ContentUserFeedback.
Submeter e ver comentários