O modelo de objeto de expressão regularThe Regular Expression Object Model

Este tópico descreve o modelo do objeto usado ao trabalhar com expressões regulares do .NET.This topic describes the object model used in working with .NET regular expressions. Ele contém as seções a seguir:It contains the following sections:

O mecanismo da expressão regularThe Regular Expression Engine

O mecanismo de expressões regulares no .NET é representada pela classe Regex.The regular expression engine in .NET is represented by the Regex class. O mecanismo de expressões regulares é responsável por analisar e compilar uma expressão regular e realizar operações que correspondem ao padrão da expressão regular com uma cadeia de caracteres de entrada.The regular expression engine is responsible for parsing and compiling a regular expression, and for performing operations that match the regular expression pattern with an input string. O mecanismo é o componente central no modelo do objeto da expressão regular do .NET.The engine is the central component in the .NET regular expression object model.

Você pode usar o mecanismo de expressões regulares de duas maneiras:You can use the regular expression engine in either of two ways:

  • Ao calcular os métodos estáticos da classe Regex.By calling the static methods of the Regex class. Os parâmetros do método incluem a cadeia de caracteres de entrada e o padrão da expressão regular.The method parameters include the input string and the regular expression pattern. O mecanismo de expressões regulares armazena em cache expressões regulares que são usadas em chamadas de método estático; por isso, chamadas repetidas a métodos de expressão regular estáticos que usam a mesma expressão regular oferecem um desempenho relativamente bom.The regular expression engine caches regular expressions that are used in static method calls, so repeated calls to static regular expression methods that use the same regular expression offer relatively good performance.

  • Ao instanciar um objeto Regex, transmitindo uma expressão regular ao construtor da classe.By instantiating a Regex object, by passing a regular expression to the class constructor. Nesse caso, o objeto Regex é imutável (somente leitura) e representa um mecanismo de expressão regular que está ligado rigorosamente a uma única expressão regular.In this case, the Regex object is immutable (read-only) and represents a regular expression engine that is tightly coupled with a single regular expression. Como as expressões regulares usadas por instâncias Regex não são armazenadas em cache, você não deve instanciar um objeto Regex várias vezes com a mesma expressão regular.Because regular expressions used by Regex instances are not cached, you should not instantiate a Regex object multiple times with the same regular expression.

Você pode chamar os métodos da classe Regex para realizar as seguintes operações:You can call the methods of the Regex class to perform the following operations:

  • Determinar se uma cadeia de caracteres corresponde a um padrão de expressão regular.Determine whether a string matches a regular expression pattern.

  • Extrair uma única correspondência ou a primeira correspondência.Extract a single match or the first match.

  • Extrair todas as correspondências.Extract all matches.

  • Substituir uma subcadeia de caracteres correspondida.Replace a matched substring.

  • Dividir uma cadeia única em uma matriz de cadeias de caracteres.Split a single string into an array of strings.

Essas operações são descritas nas seções a seguir.These operations are described in the following sections.

Correspondendo a um padrão de expressão regularMatching a Regular Expression Pattern

O método Regex.IsMatch retorna true se a cadeia corresponder ao padrão, ou false se não corresponder.The Regex.IsMatch method returns true if the string matches the pattern, or false if it does not. Geralmente, o método IsMatch é usado para validar a entrada da cadeia de caracteres.The IsMatch method is often used to validate string input. Por exemplo, o código a seguir assegura que uma cadeia de caracteres corresponda a um número do cadastro de pessoas físicas válido nos Estados Unidos.For example, the following code ensures that a string matches a valid social security number in the United States.

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 da expressão regular ^\d{3}-\d{2}-\d{4}$ é interpretado conforme mostrado na tabela a seguir.The regular expression pattern ^\d{3}-\d{2}-\d{4}$ is interpreted as shown in the following table.

PadrãoPattern DescriçãoDescription
^ Corresponder ao início da cadeia de caracteres de entrada.Match the beginning of the input string.
\d{3} Corresponder a três dígitos decimais.Match three decimal digits.
- Corresponder a um hífen.Match a hyphen.
\d{2} Corresponde a dois dígitos decimais.Match two decimal digits.
- Corresponder a um hífen.Match a hyphen.
\d{4} Corresponder a quatro dígitos decimais.Match four decimal digits.
$ Corresponder ao final da cadeia de caracteres de entrada.Match the end of the input string.

Extraindo uma única correspondência ou a primeira correspondênciaExtracting a Single Match or the First Match

O método Regex.Match retorna um objeto Match que contém informações sobre a primeira subcadeia de caracteres que corresponde a um padrão de expressão regular.The Regex.Match method returns a Match object that contains information about the first substring that matches a regular expression pattern. Se a propriedade Match.Success retornar true, indicando que uma correspondência foi localizada, você pode recuperar informações sobre correspondências subsequentes chamando o método Match.NextMatch.If the Match.Success property returns true, indicating that a match was found, you can retrieve information about subsequent matches by calling the Match.NextMatch method. Essas chamadas de método podem continuar até que a propriedade Match.Success retorne false.These method calls can continue until the Match.Success property returns false. Por exemplo, o código a seguir usa o método Regex.Match(String, String) para localizar a primeira ocorrência de uma palavra duplicada em uma cadeia de caracteres.For example, the following code uses the Regex.Match(String, String) method to find the first occurrence of a duplicated word in a string. Em seguida, ele chama o método Match.NextMatch para encontrar ocorrências adicionais.It then calls the Match.NextMatch method to find any additional occurrences. O exemplo examina a propriedade Match.Success após cada chamada de método para determinar se a correspondência atual foi bem-sucedida e se uma chamada para o método Match.NextMatch deve seguir.The example examines the Match.Success property after each method call to determine whether the current match was successful and whether a call to the Match.NextMatch method should follow.

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 da expressão regular \b(\w+)\W+(\1)\b é interpretado conforme mostrado na tabela a seguir.The regular expression pattern \b(\w+)\W+(\1)\b is interpreted as shown in the following table.

PadrãoPattern DescriçãoDescription
\b Começa a correspondência em um limite de palavra.Begin the match on a word boundary.
(\w+) Fazer a correspondência a um ou mais caracteres de palavra.Match one or more word characters. Este é o primeiro grupo de captura.This is the first capturing group.
\W+ Estabeleça a correspondência com um ou mais caracteres que não compõem palavras.Match one or more non-word characters.
(\1) Corresponder à primeira cadeia capturada.Match the first captured string. Este é o segundo grupo de captura.This is the second capturing group.
\b Termina a correspondência em um limite de palavra.End the match on a word boundary.

Extraindo todas as correspondênciasExtracting All Matches

O método Regex.Matches retorna um objeto MatchCollection que contém informações sobre todas as correspondências que o mecanismo de expressão regular localizou na cadeia de caracteres de entrada.The Regex.Matches method returns a MatchCollection object that contains information about all matches that the regular expression engine found in the input string. Por exemplo, o exemplo anterior poderia ser regravado para chamar o método Matches ao invés dos métodos Match e NextMatch.For example, the previous example could be rewritten to call the Matches method instead of the Match and NextMatch methods.

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 subcadeia de caracteres correspondidaReplacing a Matched Substring

O método Regex.Replace substitui cada subcadeia de caracteres que corresponde ao padrão da expressão regular com uma cadeia de caracteres ou padrão de expressão regular especificado, e retorna a cadeia de caracteres de entrada inteira com as substituições.The Regex.Replace method replaces each substring that matches the regular expression pattern with a specified string or regular expression pattern, and returns the entire input string with replacements. Por exemplo, o código a seguir adiciona um símbolo de moeda dos Estados Unidos antes de um número decimal em uma cadeia de caracteres.For example, the following code adds a U.S. currency symbol before a decimal number in a string.

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 da expressão regular \b\d+\.\d{2}\b é interpretado conforme mostrado na tabela a seguir.The regular expression pattern \b\d+\.\d{2}\b is interpreted as shown in the following table.

PadrãoPattern DescriçãoDescription
\b Começar a correspondência em um limite de palavra.Begin the match at a word boundary.
\d+ Corresponde a um ou mais dígitos decimais.Match one or more decimal digits.
\. Corresponde a um ponto final.Match a period.
\d{2} Corresponde a dois dígitos decimais.Match two decimal digits.
\b Termina a correspondência em um limite de palavra.End the match at a word boundary.

O padrão de substituição $$$& é interpretado conforme a tabela a seguir.The replacement pattern $$$& is interpreted as shown in the following table.

PadrãoPattern Cadeia de caracteres de substituiçãoReplacement string
$$ O caractere de cifrão ($).The dollar sign ($) character.
$& A subcadeia de caracteres correspondida inteira.The entire matched substring.

Dividindo uma cadeia de caracteres única em uma matriz de cadeias de caracteresSplitting a Single String into an Array of Strings

O método Regex.Split divide a cadeia de caracteres de entrada nas posições definidas por uma correspondência de expressão regular.The Regex.Split method splits the input string at the positions defined by a regular expression match. Por exemplo, o código a seguir coloca os itens em uma lista numerada em uma matriz de cadeia de caracteres.For example, the following code places the items in a numbered list into a string array.

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 da expressão regular \b\d{1,2}\.\s é interpretado conforme mostrado na tabela a seguir.The regular expression pattern \b\d{1,2}\.\s is interpreted as shown in the following table.

PadrãoPattern DescriçãoDescription
\b Começar a correspondência em um limite de palavra.Begin the match at a word boundary.
\d{1,2} Corresponder a um ou dois dígitos decimais.Match one or two decimal digits.
\. Corresponde a um ponto final.Match a period.
\s Corresponde a um caractere de espaço em branco.Match a white-space character.

A coleção de correspondência e os objetos de correspondênciaThe MatchCollection and Match Objects

Métodos regex retornam dois objetos que fazem parte do modelos de objeto de expressão regular: os objetos MatchCollection e Match.Regex methods return two objects that are part of the regular expression object model: the MatchCollection object, and the Match object.

A coleção de correspondênciaThe Match Collection

O método Regex.Matches retorna um objeto MatchCollection que contém objetos Match que representam todas as correspondências localizadas pelo mecanismo de expressão regular na ordem em que elas ocorrem na cadeia de caracteres de entrada.The Regex.Matches method returns a MatchCollection object that contains Match objects that represent all the matches that the regular expression engine found, in the order in which they occur in the input string. Se não houver correspondências, o método retorna um objeto MatchCollection sem membros.If there are no matches, the method returns a MatchCollection object with no members. A propriedade MatchCollection.Item[] permite que você acesse membros individuais da coleção por índice, de zero a um valor uma vez menor do que o valor da propriedade MatchCollection.Count.The MatchCollection.Item[] property lets you access individual members of the collection by index, from zero to one less than the value of the MatchCollection.Count property. Item[] é o indexador da coleção (no C#) e a propriedade padrão (no Visual Basic).Item[] is the collection's indexer (in C#) and default property (in Visual Basic).

Por padrão, a chamada para o método Regex.Matches usa a avaliação lenta para preencher o objeto MatchCollection.By default, the call to the Regex.Matches method uses lazy evaluation to populate the MatchCollection object. O acesso a propriedades que requerem uma coleção completamente preenchida, como as propriedades MatchCollection.Count e MatchCollection.Item[], pode envolver uma penalização de desempenho.Access to properties that require a fully populated collection, such as the MatchCollection.Count and MatchCollection.Item[] properties, may involve a performance penalty. Como resultado, recomendamos que você acesse a coleção usando o objeto IEnumerator retornado pelo método MatchCollection.GetEnumerator.As a result, we recommend that you access the collection by using the IEnumerator object that is returned by the MatchCollection.GetEnumerator method. Linguagens individuais oferecem constructos, como For Each no Visual Basic e foreach no C#, que encapsulam a interface IEnumerator da coleção.Individual languages provide constructs, such as For Each in Visual Basic and foreach in C#, that wrap the collection's IEnumerator interface.

O exemplo a seguir usa o método Regex.Matches(String) para preencher um objeto MatchCollection com todas as correspondências localizadas em uma cadeia de caracteres de entrada.The following example uses the Regex.Matches(String) method to populate a MatchCollection object with all the matches found in an input string. O exemplo enumera a coleção, copia as correspondências para uma matriz de cadeia de caracteres e registra as posições dos caracteres em uma matriz de inteiros.The example enumerates the collection, copies the matches to a string array, and records the character positions in an integer array.

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.

A correspondênciaThe Match

A classe Match representa o resultado de uma única correspondência de expressão regular.The Match class represents the result of a single regular expression match. É possível acessar objetos Match de duas formas:You can access Match objects in two ways:

  • Recuperando-os do objeto MatchCollection que é retornado pelo método Regex.Matches.By retrieving them from the MatchCollection object that is returned by the Regex.Matches method. Para recuperar objetos Match individuais, itere a coleção usando um constructo foreach (no C#) ou For Each...Next (no Visual Basic) ou use a propriedade MatchCollection.Item[] para recuperar um objeto Match específico por índice ou por nome.To retrieve individual Match objects, iterate the collection by using a foreach (in C#) or For Each...Next (in Visual Basic) construct, or use the MatchCollection.Item[] property to retrieve a specific Match object either by index or by name. Também é possível recuperar objetos Match individuais da coleção iterando a coleção por índice, de zero a um valor uma vez menor do que o número de objetos na coleção de dados.You can also retrieve individual Match objects from the collection by iterating the collection by index, from zero to one less that the number of objects in the collection. Entretanto, esse método não utiliza a avaliação lenta, pois ele acessa a propriedade MatchCollection.Count.However, this method does not take advantage of lazy evaluation, because it accesses the MatchCollection.Count property.

    O exemplo a seguir recupera objetos Match individuais de um objeto MatchCollection iterando a coleção usando o constructo foreach ou For Each...Next.The following example retrieves individual Match objects from a MatchCollection object by iterating the collection using the foreach or For Each...Next construct. A expressão regular simplesmente corresponde a cadeia de caracteres “abc” na cadeia de caracteres de entrada.The regular expression simply matches the string "abc" in the input string.

    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.
    
  • Ao chamar o método Regex.Match, que retorna um objeto Match que representa a primeira correspondência em uma cadeia de caracteres ou parte de uma cadeia.By calling the Regex.Match method, which returns a Match object that represents the first match in a string or a portion of a string. É possível determinar se a correspondência foi localizada recuperando o valor da propriedade Match.Success.You can determine whether the match has been found by retrieving the value of the Match.Success property. Para recuperar objetos Match que representam correspondências subsequentes, chame o método Match.NextMatch repetidamente, até que a propriedade Success do objeto Match retornado seja false.To retrieve Match objects that represent subsequent matches, call the Match.NextMatch method repeatedly, until the Success property of the returned Match object is false.

    O exemplo a seguir usa os métodos Regex.Match(String, String) e Match.NextMatch para corresponder a cadeia de caracteres "abc" na cadeia de caracteres de entrada.The following example uses the Regex.Match(String, String) and Match.NextMatch methods to match the string "abc" in the input string.

    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 classe Match retornam objetos de coleção:Two properties of the Match class return collection objects:

  • A propriedade Match.Groups retorna um objeto GroupCollection que contém informações sobre as subcadeias de caracteres que correspondem grupos de captura no padrão de expressão regular.The Match.Groups property returns a GroupCollection object that contains information about the substrings that match capturing groups in the regular expression pattern.

  • A propriedade Match.Captures retorna um objeto CaptureCollection de uso limitado.The Match.Captures property returns a CaptureCollection object that is of limited use. A coleção não é preenchida para um objeto Match cuja propriedade Success é false.The collection is not populated for a Match object whose Success property is false. Caso contrário, ela contém um único objeto Capture que possui as mesmas informações do objeto Match.Otherwise, it contains a single Capture object that has the same information as the Match object.

Para obter mais informações sobre esses objetos, consulte as seções A coleção de Grupo e A coleção Capture mais adiante neste tópico.For more information about these objects, see The Group Collection and The Capture Collection sections later in this topic.

Duas propriedades adicionais da classe Match oferecem informações sobre a correspondência.Two additional properties of the Match class provide information about the match. A propriedade Match.Value retorna a subcadeia na cadeia de caracteres de entrada que corresponde ao padrão de expressão regular.The Match.Value property returns the substring in the input string that matches the regular expression pattern. A propriedade Match.Index retorna a posição inicial baseada em zero da cadeia correspondida na cadeia de caracteres de entrada.The Match.Index property returns the zero-based starting position of the matched string in the input string.

A classe Match também tem dois métodos de correspondência de padrões:The Match class also has two pattern-matching methods:

  • O método Match.NextMatch localiza a correspondência após a correspondência representada pelo objeto Match atual e retorna um objeto Match que representa essa correspondência.The Match.NextMatch method finds the match after the match represented by the current Match object, and returns a Match object that represents that match.

  • O método Match.Result realiza uma operação de substituição especificada na cadeia de caracteres correspondida e retorna o resultado.The Match.Result method performs a specified replacement operation on the matched string and returns the result.

O exemplo a seguir usa o método Match.Result para inserir um símbolo de $ e um espaço antes de cada número que inclua dois dígitos fracionais.The following example uses the Match.Result method to prepend a $ symbol and a space before every number that includes two fractional digits.

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 de expressão regular \b\d+(,\d{3})*\.\d{2}\b é definido conforme mostrado na tabela a seguir.The regular expression pattern \b\d+(,\d{3})*\.\d{2}\b is defined as shown in the following table.

PadrãoPattern DescriçãoDescription
\b Começar a correspondência em um limite de palavra.Begin the match at a word boundary.
\d+ Corresponde a um ou mais dígitos decimais.Match one or more decimal digits.
(,\d{3})* Corresponder a zero ou mais ocorrências de uma vírgula seguida por três dígitos decimais.Match zero or more occurrences of a comma followed by three decimal digits.
\. Corresponder ao caractere de vírgula decimal.Match the decimal point character.
\d{2} Corresponde a dois dígitos decimais.Match two decimal digits.
\b Termina a correspondência em um limite de palavra.End the match at a word boundary.

O padrão de substituição $$ $& indica que a subcadeia de caracteres 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 $&).The replacement pattern $$ $& indicates that the matched substring should be replaced by a dollar sign ($) symbol (the $$ pattern), a space, and the value of the match (the $& pattern).

Voltar ao inícioBack to top

A coleção de grupoThe Group Collection

A propriedade Match.Groups retorna um objeto GroupCollection que contém Group objetos que representam grupos capturados em uma única correspondência.The Match.Groups property returns a GroupCollection object that contains Group objects that represent captured groups in a single match. O primeiro objeto Group na coleção (no índice 0) representa a correspondência inteira.The first Group object in the collection (at index 0) represents the entire match. Cada objeto que se segue representa os resultados de um único grupo de captura.Each object that follows represents the results of a single capturing group.

É possível recuperar objetos Group individuais na coleção usando a propriedade GroupCollection.Item[].You can retrieve individual Group objects in the collection by using the GroupCollection.Item[] property. É possível recuperar grupos não nomeados por sua posição ordinal na coleção e recuperar grupos nomeados por nome ou posição ordinal.You can retrieve unnamed groups by their ordinal position in the collection, and retrieve named groups either by name or by ordinal position. Capturas não nomeadas aparecem primeiro na coleção e são indexadas da esquerda para a direita na ordem na qual aparecem no padrão de expressão regular.Unnamed captures appear first in the collection, and are indexed from left to right in the order in which they appear in the regular expression pattern. Capturas nomeadas são indexadas após as capturas não nomeadas, da esquerda para a direita, na ordem em que aparecem no padrão de expressão regular.Named captures are indexed after unnamed captures, from left to right in the order in which they appear in the regular expression pattern. Para determinar quais grupos numerados estão disponíveis na coleção retornada para um método específico de correspondência de expressão regular, você pode chamar o método da instância Regex.GetGroupNumbers.To determine what numbered groups are available in the collection returned for a particular regular expression matching method, you can call the instance Regex.GetGroupNumbers method. Para determinar quais grupos nomeados estão disponíveis na coleção, você pode chamar o método da instância Regex.GetGroupNames.To determine what named groups are available in the collection, you can call the instance Regex.GetGroupNames method. Os dois métodos são especificamente úteis em rotinas gerais que analisam as correspondências encontradas por qualquer expressão regular.Both methods are particularly useful in general-purpose routines that analyze the matches found by any regular expression.

A propriedade GroupCollection.Item[] é o indexador da coleção no C# e a propriedade padrão do objeto da coleção no Visual Basic.The GroupCollection.Item[] property is the indexer of the collection in C# and the collection object's default property in Visual Basic. Isso significa que objetos Group individuais podem ser acessados por índice (ou por nome, no caso de grupos nomeados) como a seguir:This means that individual Group objects can be accessed by index (or by name, in the case of named groups) as follows:

Group group = match.Groups[ctr];
Dim group As Group = match.Groups(ctr)

O exemplo a seguir define uma expressão regular que usa constructos de agrupamento para capturar o mês, o dia e o ano de uma data.The following example defines a regular expression that uses grouping constructs to capture the month, day, and year of a date.

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 de expressão regular \b(\w+)\s(\d{1,2}),\s(\d{4})\b é definido conforme mostrado na tabela a seguir.The regular expression pattern \b(\w+)\s(\d{1,2}),\s(\d{4})\b is defined as shown in the following table.

PadrãoPattern DescriçãoDescription
\b Começar a correspondência em um limite de palavra.Begin the match at a word boundary.
(\w+) Fazer a correspondência a um ou mais caracteres de palavra.Match one or more word characters. Este é o primeiro grupo de captura.This is the first capturing group.
\s Corresponde a um caractere de espaço em branco.Match a white-space character.
(\d{1,2}) Corresponder a um ou dois dígitos decimais.Match one or two decimal digits. Este é o segundo grupo de captura.This is the second capturing group.
, Corresponde a uma vírgula.Match a comma.
\s Corresponde a um caractere de espaço em branco.Match a white-space character.
(\d{4}) Corresponder a quatro dígitos decimais.Match four decimal digits. Este é o terceiro grupo de captura.This is the third capturing group.
\b Termina a correspondência em um limite de palavra.End the match on a word boundary.

Voltar ao inícioBack to top

O grupo capturadoThe Captured Group

A classe Group representa o resultado de um único grupo de captura.The Group class represents the result from a single capturing group. Objetos de grupo que representam os grupos de captura definidos em uma expressão regular são retornados pela propriedade Item[] do objeto GroupCollection retornado pela propriedade Match.Groups.Group objects that represent the capturing groups defined in a regular expression are returned by the Item[] property of the GroupCollection object returned by the Match.Groups property. A propriedade Item[] é o indexador (no C#) e a propriedade padrão (no Visual Basic) da classe Group.The Item[] property is the indexer (in C#) and the default property (in Visual Basic) of the Group class. Você também pode recuperar membros individuais iterando a coleção usando o constructo foreach ou For Each.You can also retrieve individual members by iterating the collection using the foreach or For Each construct. Para ver um exemplo, consulte a seção anterior.For an example, see the previous section.

O exemplo a seguir usa constructos de agrupamento aninhados para capturar subcadeias de caracteres em grupos.The following example uses nested grouping constructs to capture substrings into groups. O padrão de expressão regular (a(b))c corresponde à cadeia de caracteres “abc”.The regular expression pattern (a(b))c matches the string "abc". Ele atribui a subcadeia “ab” ao primeiro grupo de captura e a subcadeia de caracteres “b” ao segundo grupo de captura.It assigns the substring "ab" to the first capturing group, and the substring "b" to the second capturing group.

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 constructos de agrupamento nomeados para capturar subcadeias de caracteres de uma cadeia que contém dados no formato “DATANAME:VALUE”, que a expressão regular divide usando dois pontos (:).The following example uses named grouping constructs to capture substrings from a string that contains data in the format "DATANAME:VALUE", which the regular expression splits at the colon (:).

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 de expressão regular ^(?<name>\w+):(?<value>\w+) é definido conforme mostrado na tabela a seguir.The regular expression pattern ^(?<name>\w+):(?<value>\w+) is defined as shown in the following table.

PadrãoPattern DescriçãoDescription
^ Começar a correspondência no início da cadeia de caracteres de entrada.Begin the match at the beginning of the input string.
(?<name>\w+) Fazer a correspondência a um ou mais caracteres de palavra.Match one or more word characters. O nome deste grupo de captura é name.The name of this capturing group is name.
: Corresponder a dois pontos.Match a colon.
(?<value>\w+) Fazer a correspondência a um ou mais caracteres de palavra.Match one or more word characters. O nome deste grupo de captura é value.The name of this capturing group is value.

As propriedades da classe Group fornecem informações sobre o grupo capturado: a propriedade Group.Value contém a subcadeia de caracteres capturada, a propriedade Group.Index indica a posição inicial do grupo capturado no texto de entrada, a propriedade Group.Length contém o comprimento do texto capturado e a propriedade Group.Success indica se uma subcadeia de caracteres corresponde ao padrão definido pelo grupo de captura.The properties of the Group class provide information about the captured group: The Group.Value property contains the captured substring, the Group.Index property indicates the starting position of the captured group in the input text, the Group.Length property contains the length of the captured text, and the Group.Success property indicates whether a substring matched the pattern defined by the capturing group.

Aplicar quantificadores a um grupo (para obter mais informações, confira Quantificadores) modifica a relação de uma captura por grupo de captura de duas formas:Applying quantifiers to a group (for more information, see Quantifiers) modifies the relationship of one capture per capturing group in two ways:

  • 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.If the * or *? quantifier (which specifies zero or more matches) is applied to a group, a capturing group may not have a match in the input string. Quando não há texto capturado, as propriedades do objeto Group são definidas como mostrado na tabela a seguir.When there is no captured text, the properties of the Group object are set as shown in the following table.

    Propriedade do grupoGroup property ValorValue
    Success false
    Value String.Empty
    Length 00

    O exemplo a seguir ilustra esse cenário.The following example provides an illustration. No padrão de expressão regular aaa(bbb)*ccc, o primeiro grupo de captura (a subcadeia de caracteres “bbb”) pode ser correspondido a zero ou mais vezes.In the regular expression pattern aaa(bbb)*ccc, the first capturing group (the substring "bbb") can be matched zero or more times. Como a cadeia de caracteres de entrada “aaaccc” corresponde ao padrão, o grupo de captura não tem correspondência.Because the input string "aaaccc" matches the pattern, the capturing group does not have a 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.
    
    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 diversas ocorrências de um padrão que é definido por um grupo de captura.Quantifiers can match multiple occurrences of a pattern that is defined by a capturing group. Nesse caso, as propriedades Value e Length de um objeto Group contêm informações somente sobre a última subcadeia de caracteres capturada.In this case, the Value and Length properties of a Group object contain information only about the last captured substring. Por exemplo, a seguinte expressão regular corresponde a uma única sentença que termina com um ponto.For example, the following regular expression matches a single sentence that ends in a period. Ela utiliza dois constructos de agrupamento: o primeiro captura palavras individuais, juntamente com um caractere de espaço em branco; o segundo captura palavras individuais.It uses two grouping constructs: The first captures individual words along with a white-space character; the second captures individual words. Como a saída do exemplo mostra, embora a expressão regular tenha sucesso ao capturar uma sequência inteira, o segundo grupo de captura só captura a última palavra.As the output from the example shows, although the regular expression succeeds in capturing an entire sentence, the second capturing group captures only the last word.

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

Voltar ao inícioBack to top

A coleção de capturaThe Capture Collection

O objeto Group contém informações somente sobre a última captura.The Group object contains information only about the last capture. No entanto, o conjunto inteiro de capturas realizadas por um grupo de captura ainda estará disponível do objeto CaptureCollection que é retornado pela propriedade Group.Captures.However, the entire set of captures made by a capturing group is still available from the CaptureCollection object that is returned by the Group.Captures property. Cada membro da coleção é um objeto Capture que representa uma captura realizada por esse grupo de captura, na ordem na qual elas foram capturadas (e, portanto, na ordem em que as cadeias capturadas foram correspondidas da esquerda para a direita na cadeia de caracteres de entrada).Each member of the collection is a Capture object that represents a capture made by that capturing group, in the order in which they were captured (and, therefore, in the order in which the captured strings were matched from left to right in the input string). Você pode recuperar objetos Capture individuais na coleção de duas formas:You can retrieve individual Capture objects from the collection in either of two ways:

  • Ao iterar pela coleção usando um constructo como foreach (no C#) ou For Each (no Visual Basic).By iterating through the collection using a construct such as foreach (in C#) or For Each (in Visual Basic).

  • Ao usar a propriedade CaptureCollection.Item[] para recuperar um objeto específico por índice.By using the CaptureCollection.Item[] property to retrieve a specific object by index. A propriedade Item[] é a propriedade padrão (no Visual Basic) ou o indexador (no C#) do objeto CaptureCollection.The Item[] property is the CaptureCollection object's default property (in Visual Basic) or indexer (in C#).

Se um quantificador não for aplicado a um grupo de captura, o objeto CaptureCollection conterá um único objeto Capture de pouco interesse, pois ele fornece informações sobre a mesma correspondência que seu objeto Group.If a quantifier is not applied to a capturing group, the CaptureCollection object contains a single Capture object that is of little interest, because it provides information about the same match as its Group object. Se um quantificador for aplicado a um grupo de captura, o objeto CaptureCollection conterá todas as capturas realizadas pelo grupo de captura, e o último membro da coleção representará a mesma captura do objeto Group.If a quantifier is applied to a capturing group, the CaptureCollection object contains all captures made by the capturing group, and the last member of the collection represents the same capture as the Group object.

Por exemplo, se você usar o padrão de expressão regular ((a(b))c)+ (em que o quantificador + especifica uma ou mais correspondências) para capturar correspondências da cadeia de caracteres "abcabcabc", o objeto CaptureCollection para cada objeto Group conterá três membros.For example, if you use the regular expression pattern ((a(b))c)+ (where the + quantifier specifies one or more matches) to capture matches from the string "abcabcabc", the CaptureCollection object for each Group object contains three members.

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

O exemplo a seguir usa a expressão regular (Abc)+ para localizar uma ou mais execuções consecutivas da cadeia de caracteres “Abc” na cadeia “XYZAbcAbcAbcXYZAbcAb”.The following example uses the regular expression (Abc)+ to find one or more consecutive runs of the string "Abc" in the string "XYZAbcAbcAbcXYZAbcAb". O exemplo ilustra o uso da propriedade Group.Captures para retornar vários grupos de subcadeias de caracteres capturadas.The example illustrates the use of the Group.Captures property to return multiple groups of captured substrings.

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  

Voltar ao inícioBack to top

A captura individualThe Individual Capture

A classe Capture contém os resultados de uma única captura de subexpressão.The Capture class contains the results from a single subexpression capture. A propriedade Capture.Value contém o texto correspondido, e a propriedade Capture.Index indica a posição baseada em zero na cadeia de caracteres de entrada na qual a subcadeia de caracteres correspondida começa.The Capture.Value property contains the matched text, and the Capture.Index property indicates the zero-based position in the input string at which the matched substring begins.

O exemplo a seguir analisa uma cadeia de caracteres de entrada para a temperatura das cidades escolhidas.The following example parses an input string for the temperature of selected cities. Uma vírgula (“,”) é usada para separar uma cidade e sua temperatura, enquanto um ponto e vírgula (“;”) é usado para separar os dados de cada cidade.A comma (",") is used to separate a city and its temperature, and a semicolon (";") is used to separate each city's data. A cadeia de caracteres de entrada inteira representa uma única correspondência.The entire input string represents a single match. No padrão de expressão regular ((\w+(\s\w+)*),(\d+);)+, usado para analisar a cadeia de caracteres, o nome da cidade é atribuído ao segundo grupo de captura, enquanto a temperatura é atribuída ao quarto grupo de captura.In the regular expression pattern ((\w+(\s\w+)*),(\d+);)+, which is used to parse the string, the city name is assigned to the second capturing group, and the temperature is assigned to the fourth capturing group.

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 como mostrado na tabela a seguir.The regular expression is defined as shown in the following table.

PadrãoPattern DescriçãoDescription
\w+ Fazer a correspondência a um ou mais caracteres de palavra.Match one or more word characters.
(\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.Match zero or more occurrences of a white-space character followed by one or more word characters. Este padrão corresponde a nomes de cidade com várias palavras.This pattern matches multi-word city names. Este é o terceiro grupo de captura.This is the third capturing group.
(\w+(\s\w+)*) Corresponder a um ou mais caracteres de palavra seguido por zero ou mais ocorrências de um caractere de espaço em branco e um ou mais caracteres de palavra.Match one or more word characters followed by zero or more occurrences of a white-space character and one or more word characters. Este é o segundo grupo de captura.This is the second capturing group.
, Corresponde a uma vírgula.Match a comma.
(\d+) Corresponder a um ou mais dígitos.Match one or more digits. Este é o quarto grupo de captura.This is the fourth capturing group.
; Corresponder a um ponto e vírgula.Match a semicolon.
((\w+(\s\w+)*),(\d+);)+ Corresponder ao padrão de uma palavra seguida por qualquer palavra adicional seguida por uma vírgula, um ou mais dígitos e um ponto e vírgula, uma ou mais vezes.Match the pattern of a word followed by any additional words followed by a comma, one or more digits, and a semicolon, one or more times. Este é o primeiro grupo de captura.This is the first capturing group.

Veja tambémSee also