O modelo de objeto de expressão Regular

Este tópico descreve o modelo de objeto usado para trabalhar com.Expressões regulares do NET Framework. Ele contém as seguintes seções:

• O mecanismo de expressões regulares

• Os objetos de correspondência e de MatchCollection

• A coleção de grupo

• O grupo capturado

• A coleção de captura

• A captura Individual

O mecanismo de expressões regulares

O mecanismo de expressões regulares na.NET Framework é representado pela Regex classe. O mecanismo de expressão regular é responsável pelo análise e compilação de uma expressão regular e para a realização de operações que correspondem ao padrão de expressão regular com uma seqüência de caracteres de entrada. O mecanismo é o componente central do.Modelo de objeto de expressão regular do NET Framework.

Você pode usar o mecanismo de expressões regulares em uma destas duas maneiras:

• Chamando os métodos estáticos da Regex classe. Os parâmetros do método incluem a seqüência de caracteres de entrada e o padrão de expressão regular. O mecanismo de expressão regular caches de expressões regulares que são usadas em chamadas de método estático, portanto repetidas chamadas a métodos estáticos de expressão regular que usam a mesma expressão regular oferecem relativamente bom desempenho.

• Instanciando um Regex o objeto, passando uma expressão regular para o construtor de classe. Nesse caso, o Regex objeto é imutável (somente leitura) e representa um mecanismo de expressão regular que está intimamente ligado com uma única expressão regular. Porque expressões regulares usada por Regex instâncias não são armazenados 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 de Regex classe para executar as seguintes operações:

• Determine se uma seqüência 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 substring correspondida.

• Divida uma única cadeia de caracteres em uma matriz de seqüências de caracteres.

Essas operações são descritas nas seções a seguir.

Um padrão de expressão Regular de correspondência.

O Regex.IsMatch método retorna true se a seqüência de caracteres corresponde ao padrão, ou false se ele não não. O IsMatch método é freqüentemente usado para validar a entrada de seqüência de caracteres. Por exemplo, o código a seguir assegura que uma seqüência de caracteres corresponde a um número válido de segurança social nos Estados Unidos.

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

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

O padrão de expressão regular ^\d{3}-\d{2}-\d{4}$ é interpretado como mostrado na tabela a seguir.

Extraindo uma única correspondência ou a primeira correspondência

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 o Match.Success retorna a propriedade true, indicando que foi encontrada uma correspondência, você pode recuperar informações sobre as correspondências subseqüentes chamando o Match.NextMatch método. Essas chamadas de método podem continuar até que o Match.Success retorna a propriedade false. Por exemplo, o código a seguir usa a Regex.Match(String, String) método para localizar a primeira ocorrência de uma palavra duplicada em uma seqüência de caracteres. Em seguida, chama o Match.NextMatch método para localizar quaisquer ocorrências adicionais. O exemplo examina o 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.

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.

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.

O padrão de expressão regular \b(\w+)\W+(\1)\b é interpretado como mostrado na tabela a seguir.

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 é encontrado na seqüência de caracteres de entrada. Por exemplo, o exemplo anterior poderia ser reescrito para chamar o Matches método em vez da Match e NextMatch métodos.

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.

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.

Substituindo uma Substring correspondente

O Regex.Replace método substitui cada subseqüência de caracteres que corresponda ao padrão de expressão regular com uma seqüência de caracteres especificada ou padrão de expressão regular e retorna a seqüência inteira de entrada com substituições. Por exemplo, o código a seguir adiciona um americano. símbolo de moeda antes de um número decimal em uma seqüência de caracteres.

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

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

O padrão de expressão regular \b\d+\.\d{2}\b é interpretado como mostrado na tabela a seguir.

O padrão de substituição $$$& é interpretado como mostrado na tabela a seguir.

A divisão de uma única cadeia de caracteres em uma matriz de seqüências de caracteres

O Regex.Split método divide a seqüência de caracteres de entrada nas posições definidas por uma correspondência da expressão regular. Por exemplo, o código a seguir coloca itens em uma lista numerada em uma matriz de cadeia de caracteres.

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

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

O padrão de expressão regular \b\d{1,2}\.\s é interpretado como mostrado na tabela a seguir.

Os objetos de correspondência e de MatchCollection

Dois objetos que fazem parte do modelo de objeto de expressão regular de retorno de métodos de Regex: o MatchCollection o objeto e o Match objeto.

A coleção de correspondência

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 é encontrado, na ordem em que ocorrem na seqüência de caracteres de entrada. Se não houver nenhuma correspondência, o método retorna um MatchCollection o objeto com sem membros. O MatchCollection.Item permite a propriedade acessar membros individuais da coleção pelo índice, a partir de zero a menos que o valor da MatchCollection.Count propriedade. Itemé o indexador (em C#) e a propriedade do padrão (em Visual Basic) da coleção.

Por padrão, a chamada para o Regex.Matches método usa a avaliação lenta para preencher o MatchCollection objeto. Acesso às propriedades que exigem uma coleção completamente preenchida, como o MatchCollection.Count e MatchCollection.Item Propriedades, pode envolver uma penalidade de desempenho. Como resultado, recomendamos que você acessar a coleção usando o IEnumerator o objeto retornado pelo MatchCollection.GetEnumerator método. Os idiomas individuais fornecem construções, como For Each em Visual Basic e foreach em C#, que quebra a coleção IEnumerator interface.

O exemplo a seguir usa a Regex.Matches(String) método para preencher um MatchCollection o objeto com todas as correspondências encontradas em uma seqüência 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 caractere em uma matriz de inteiros.

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.

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.

A correspondência

O Match classe representa o resultado de uma correspondência única expressão regular. Você pode acessar Match objetos de duas maneiras:

• Recuperando-as partir de MatchCollection objeto retornado pelo Regex.Matches método. Para recuperar individuais Match objetos, a coleção de iterar por meio de um foreach (em C#) ou For Each...Next (em Visual Basic) construir ou use o MatchCollection.Item propriedade para recuperar um determinado Match objeto pelo índice ou por nome. Você também pode recuperar individuais Match objetos da coleção, iterando a coleção pelo índice, de zero para um menor que o número de objetos na coleção. No entanto, esse método não tirar proveito de uma avaliação lenta, porque ele acessa o MatchCollection.Count propriedade.

  O exemplo a seguir recupera individuais Match objetos de um MatchCollection objeto pela iteração na coleção, use o foreach ou For Each...Next construção. A expressão regular corresponde simplesmente a seqüência de caracteres "abc" a seqüência de caracteres de entrada.

  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.
  

  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.
  

• Chamando o Regex.Match método, que retorna um Match objeto que representa a primeira correspondência em uma seqüência ou uma parte de uma seqüência de caracteres. Você pode determinar se a correspondência foi encontrada Recuperando o valor de Match.Success propriedade. Para recuperar Match objetos que representam as correspondências subseqüentes, chamar o Match.NextMatch método repetidamente, até o Success propriedade do retornado Match objeto é false.

  O exemplo a seguir usa a Regex.Match(String, String) e Match.NextMatch métodos para coincidir com a seqüência de caracteres "abc" a seqüência de caracteres de entrada.

  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.
  

  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.
  

Duas propriedades da Match classe retorno de coleção de objetos:

• O Match.Groups propriedade retorna um GroupCollection objeto que contém informações sobre os substrings que correspondem a grupos de captura no padrão de expressão regular.

• O Group.Captures propriedade retorna um CaptureCollection objeto que é de uso limitado. A coleção não é preenchida para uma Match objeto cuja Success é a propriedade 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 o A coleção de grupo e A coleção de captura seções posteriormente neste tópico.

Duas propriedades adicionais do Match classe fornecem informações sobre a correspondência. O Match.Value propriedade retorna a subseqüência da seqüência de entrada que coincide com o padrão de expressão regular. O Match.Index propriedade retorna a posição inicial baseada em zero da seqüência de caracteres correspondente na seqüência de caracteres de entrada.

O 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 atual Match objeto e retorna um Match objeto que representa o correspondente.

• O Match.Result método executa uma operação de substituição especificado na seqüência de caracteres correspondente e retorna o resultado.

O exemplo a seguir usa a Match.Result método para colocar um cifrão ($) e um espaço antes de cada número que inclui dois dígitos fracionais.

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

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

O padrão de expressão regular \b\d+(,\d{3})*\.\d{2}\b é definido como mostrado na tabela a seguir.

O padrão de substituição $$ $& indica que a substring correspondida 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).

Voltar ao topo

A coleção de grupo

O Match.Groups propriedade retorna um GroupCollection objeto que contém Group capturados de objetos que representam grupos em uma única correspondência. O primeiro Group o objeto da coleção (no índice 0) representa toda correspondência. Cada objeto que segue representa os resultados de um único grupo de captura.

Você pode recuperar individuais Group objetos na coleção usando o GroupCollection.Item propriedade. Você pode recuperar grupos sem nome, por sua posição ordinal da coleção e recuperar grupos nomeados pelo nome ou pela posição ordinal. Sem nome capturas aparecem primeira na coleção e são indexadas da esquerda para a direita na ordem em que aparecem no padrão de expressão regular. Capturas nomeadas são indexadas após captura sem nome, da esquerda para a direita na ordem em que aparecem no padrão de expressão regular.

O GroupCollection.Item propriedade é o indexador da coleção C# e propriedade de padrão do objeto da coleção Visual Basic. Isso significa que essa pessoa Group objetos podem ser acessados pelo índice (ou pelo nome, no caso de grupos nomeados) da seguinte maneira:

Dim group As Group = match.Groups(ctr)         

Group group = match.Groups[ctr];         

O exemplo a seguir define uma expressão regular que usa o agrupamento construções para capturar o mês, dia e ano de uma data.

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

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

O padrão de expressão regular \b(\w+)\s(\d{1,2}),\s(\d{4})\b é definido como mostrado na tabela a seguir.

Voltar ao topo

O grupo capturado

O Group classe representa o resultado de uma única captura de grupo. Agrupar objetos que representam os grupos de capturando definidos em uma expressão regular são retornados pelo Item propriedade da GroupCollection objeto retornado pela Match.Groups propriedade. O Item propriedade é o indexador (em C#) e a propriedade padrão (em Visual Basic) da Group classe. Você também pode recuperar membros individuais iterar na coleção, use o foreach ou For Each construção. Por exemplo, consulte a seção anterior.

O exemplo a seguir usa o agrupamento aninhado construções para capturar substrings em grupos. O padrão de expressão regular (a(b))c coincide com a seqüência de caracteres "abc". Ele atribui a subseqüência "ab" o primeiro grupo de capturando e a subseqüência "b" para o segundo grupo de capturando.

 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 a seguir usa o agrupamento nomeado construções para capturar substrings de uma seqüência de dados no formato "DATANAME:VALUE", que a expressão regular que tenha sido dividida 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

O padrão de expressão regular ^(?<name>\w+):(?<value>\w+) é definido como mostrado na tabela a seguir.

As propriedades da Group classe fornecem informações sobre o grupo capturado: O Group.Value propriedade contém a subseqüência capturada, a Group.Index propriedade indica a posição inicial do grupo capturado no texto de entrada, o Group.Length propriedade contém o comprimento do texto capturado e o Group.Success propriedade indica se uma substring que correspondeu o padrão definido pelo grupo de captura.

Aplicando quantificadores a um grupo (para obter mais informações, consulte Quantificadores) modifica a relação de uma captura por grupo de duas maneiras de captura:

• Se o * ou *? quantificador (que especifica zero ou mais correspondências) é aplicada a um grupo, um grupo de captura não tenha uma correspondência na seqüência de caracteres de entrada. Quando não houver nenhum texto capturado, as propriedades do Group objeto são definidas como mostrado na tabela a seguir.

  Propriedade do grupo	Valor
  Success	false
  Value	String.Empty
  Length	0

  O exemplo a seguir fornece uma ilustração. No padrão de expressão regular aaa(bbb)*ccc, o primeiro grupo de capturando (a subseqüência "bbb") pode ser correspondido zero ou mais vezes. Porque a entrada de seqüência de caracteres "aaaccc" corresponde ao padrão, o grupo de captura não tem uma correspondência.

  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.
  

  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.
  

• Quantificadores podem combinar várias ocorrências de um padrão definido por um grupo de captura. Nesse caso, o Value e Length Propriedades de um Group objeto contém informações somente sobre a última subseqüência capturada. Por exemplo, a seguinte expressão regular corresponde a uma única sentença que termina em um período. Ele usa duas construções de agrupamento: A primeira captura palavras individuais, junto com um caractere de espaço em branco; a segunda captura palavras individuais. Como mostra a saída do exemplo, embora a expressão regular é bem-sucedida na captura de uma frase inteira, o segundo grupo de capturando captura a última palavra.

  Imports 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
  

  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: sentence
  

Voltar ao topo

A coleção de captura

O Group objeto contém informações somente sobre a última captura. Entretanto, todo o conjunto de capturas feita por um grupo de captura ainda está disponível da CaptureCollection o objeto retornado pelo Group.Captures propriedade. Cada membro da coleção é um Capture o objeto que representa uma captura feita por esse grupo de captura, na ordem em que foram capturados (e, portanto, na ordem em que as seqüências de caracteres capturadas foram combinadas da esquerda para a direita na seqüência de entrada). Você pode recuperar individuais Capture objetos da coleção em uma destas duas maneiras:

• Pela iteração através da coleção usando uma construção, como foreach (em C#) ou For Each (em Visual Basic).

• Usando o CaptureCollection.Item propriedade para recuperar um objeto específico por índice. O Item propriedade é o CaptureCollection a propriedade padrão (em Visual Basic) ou o indexador (em C#) do objeto.

Se um quantificador não será aplicado a um grupo de captura, o CaptureCollection objeto contém um único Capture objeto é pouco interessante, porque ele fornece informações sobre a coincidência mesma como seu Group objeto. Se um quantificador é aplicado a um grupo de captura, o CaptureCollection objeto contém todas as capturas efetuadas por grupo de captura e o último membro da coleção representa a captura mesma como o Group objeto.

Por exemplo, se você usar o padrão de expressão regular ((a(b))c)+ (onde o + quantificador Especifica um ou mais correspondências) capturar corresponde a partir da seqüência "abcabcabc", o CaptureCollection o objeto para cada Group objeto contém três membros.

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 dosplays 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

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

O exemplo a seguir usa a expressão regular (Abc)+ para encontrar um ou mais execuções consecutivas da seqüência de caracteres "Abc" a seqüência de caracteres "xyzabcabcabcxyzabcab". O exemplo ilustra o uso da Group.Captures propriedade para retornar a vários grupos de subseqüê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  

Voltar ao topo

A captura Individual

A classe Capture contém os resultados de uma única captura de subexpressão. O Capture.Value propriedade contém o texto correspondente e o Capture.Index propriedade indica a posição baseada em zero na seqüência de entrada na qual a substring correspondida começa.

O exemplo a seguir analisa uma seqüência de caracteres de entrada a temperatura de cidades selecionadas. Uma vírgula (",") é usado para separar uma cidade e a sua temperatura e um ponto e vírgula (";") é usado para separar os dados de cada cidade. Toda a seqüência de entrada representa uma única correspondência. No padrão de expressão regular ((\w+(\s\w+)*),(\d+);)+, que é usado para analisar a cadeia de caracteres, o nome da cidade é atribuído ao segundo grupo de capturando, e a temperatura é atribuída para o quarto grupo de captura.

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

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

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

Voltar ao topo

Consulte também

Referência

System.Text.RegularExpressions

Conceitos

Expressões Regulares do .NET Framework

Elementos de linguagem das expressões regulares