Agrupando construtores em expressões regularesGrouping Constructs in Regular Expressions

As construções de agrupamento delineiam as subexpressões de uma expressão regular e capturam a subcadeia de caracteres de uma cadeia de caracteres de entrada.Grouping constructs delineate the subexpressions of a regular expression and capture the substrings of an input string. Você pode usar construções de agrupamento para fazer isto:You can use grouping constructs to do the following:

  • Fazer a correspondência de uma subexpressão que é repetida na cadeia de caracteres de entrada.Match a subexpression that is repeated in the input string.

  • Aplicar um quantificador a uma subexpressão com diversos elementos de linguagem de expressão regular.Apply a quantifier to a subexpression that has multiple regular expression language elements. Para saber mais sobre quantificadores, confira Quantificadores.For more information about quantifiers, see Quantifiers.

  • Inclua uma subexpressão na cadeia de caracteres retornada pelos métodos Regex.Replace e Match.Result.Include a subexpression in the string that is returned by the Regex.Replace and Match.Result methods.

  • Recupere subexpressões individuais da propriedade Match.Groups e processe-as separadamente do texto correspondente como um todo.Retrieve individual subexpressions from the Match.Groups property and process them separately from the matched text as a whole.

A tabela a seguir lista os constructos de agrupamento com suporte do mecanismo de expressões regulares .NET e indica captura ou não captura.The following table lists the grouping constructs supported by the .NET regular expression engine and indicates whether they are capturing or non-capturing.

Constructo de agrupamentoGrouping construct Captura ou não capturaCapturing or noncapturing
Subexpressões correspondentesMatched subexpressions CapturandoCapturing
Subexpressões correspondentes nomeadasNamed matched subexpressions CapturandoCapturing
Definições de grupo de balanceamentoBalancing group definitions CapturandoCapturing
Grupos de não capturaNoncapturing groups Não capturaNoncapturing
Opções de grupoGroup options Não capturaNoncapturing
Asserções lookahead positivas de largura zeroZero-width positive lookahead assertions Não capturaNoncapturing
Asserções lookahead negativas de largura zeroZero-width negative lookahead assertions Não capturaNoncapturing
Asserções lookbehind positivas de largura zeroZero-width positive lookbehind assertions Não capturaNoncapturing
Asserções lookbehind negativas de largura zeroZero-width negative lookbehind assertions Não capturaNoncapturing
Subexpressões sem retrocessoNonbacktracking subexpressions Não capturaNoncapturing

Para saber mais sobre grupos e modelos de objetos de expressão regular, veja Constructos de agrupamento e objetos de expressão regular.For information on groups and the regular expression object model, see Grouping constructs and regular expression objects.

Subexpressões CoincidentesMatched Subexpressions

O constructo de agrupamento a seguir captura uma subexpressão correspondente:The following grouping construct captures a matched subexpression:

( subexpressão )( subexpression )

em que subexpression é qualquer padrão de expressão regular válido.where subexpression is any valid regular expression pattern. As capturas que usam parênteses são numeradas automaticamente, da esquerda para a direita, com base na ordem do parêntese de abertura na expressão regular, começando em um.Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. A captura que recebe o número zero é o texto que coincide com todo o padrão da expressão regular.The capture that is numbered zero is the text matched by the entire regular expression pattern.

Observação

Por padrão, o elemento da linguagem (subexpression) captura a subexpressão correspondente.By default, the (subexpression) language element captures the matched subexpression. Porém, se o parâmetro RegexOptions de um padrão de expressão regular que corresponde ao método inclui o sinalizador RegexOptions.ExplicitCapture ou se a opção n é aplicada a essa subexpressão (consulte Opções de grupo mais adiante neste tópico), a subexpressão coincidente não é capturada.But if the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression (see Group options later in this topic), the matched subexpression is not captured.

Você pode acessar os grupos capturados de quatro formas:You can access captured groups in four ways:

  • Usando o constructo de referência inversa na expressão regular.By using the backreference construct within the regular expression. A subexpressão correspondente é referenciada na mesma expressão regular usando a sintaxe \number, em que number é o número ordinal da subexpressão capturada.The matched subexpression is referenced in the same regular expression by using the syntax \number, where number is the ordinal number of the captured subexpression.

  • Usando o constructo de referência inversa nomeado na expressão regular.By using the named backreference construct within the regular expression. A subexpressão coincidente é referenciada na mesma expressão regular usando a sintaxe \k<name>, em que name é o nome de um grupo de captura, ou \k<number>, em que number é o número ordinal de um grupo de captura.The matched subexpression is referenced in the same regular expression by using the syntax \k<name>, where name is the name of a capturing group, or \k<number>, where number is the ordinal number of a capturing group. O grupo de captura tem um nome padrão que é idêntico a seu número ordinal.A capturing group has a default name that is identical to its ordinal number. Para saber mais, confira Subexpressões coincidentes nomeadas mais adiante neste tópico.For more information, see Named matched subexpressions later in this topic.

  • Ao usar a sequência de substituição $number em uma chamada de método Regex.Replace ou Match.Result, em que number é o número ordinal da subexpressão capturada.By using the $number replacement sequence in a Regex.Replace or Match.Result method call, where number is the ordinal number of the captured subexpression.

  • Usando de forma programática o objeto GroupCollection retornado pela propriedade Match.Groups.Programmatically, by using the GroupCollection object returned by the Match.Groups property. O membro na posição zero da coleção representa toda a correspondência da expressão regular.The member at position zero in the collection represents the entire regular expression match. Cada membro subsequente representa uma subexpressão correspondente.Each subsequent member represents a matched subexpression. Para obter mais informações, veja a seção Construções de agrupamento e objetos de expressão regular.For more information, see the Grouping Constructs and Regular Expression Objects section.

O exemplo a seguir mostra uma expressão regular que identifica palavras duplicadas no texto.The following example illustrates a regular expression that identifies duplicated words in text. Os dois grupos de captura padrão da expressão regular representam as duas instâncias da palavra duplicada.The regular expression pattern's two capturing groups represent the two instances of the duplicated word. A segunda instância é capturada para relatar a posição inicial na cadeia de caracteres de entrada.The second instance is captured to report its starting position in the input string.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\w+)\s(\1)";
      string input = "He said that that was the the correct answer.";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine("Duplicate '{0}' found at positions {1} and {2}.", 
                           match.Groups[1].Value, match.Groups[1].Index, match.Groups[2].Index);
   }
}
// The example displays the following output:
//       Duplicate 'that' found at positions 8 and 13.
//       Duplicate 'the' found at positions 22 and 26.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\w+)\s(\1)\W"
      Dim input As String = "He said that that was the the correct answer."
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine("Duplicate '{0}' found at positions {1} and {2}.", _
                           match.Groups(1).Value, match.Groups(1).Index, match.Groups(2).Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Duplicate 'that' found at positions 8 and 13.
'       Duplicate 'the' found at positions 22 and 26.

Este é o padrão da expressão regular:The regular expression pattern is the following:

(\w+)\s(\1)\W

A tabela a seguir mostra como o padrão da expressão regular é interpretado.The following table shows how the regular expression pattern is interpreted.

PadrãoPattern DescriçãoDescription
(\w+) Corresponde 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.
(\1) Corresponde à cadeia de caracteres no primeiro grupo capturado.Match the string in the first captured group. Este é o segundo grupo de captura.This is the second capturing group. O exemplo o atribui a um grupo capturado para que seja possível recuperar a posição inicial da palavra duplicada da propriedade Match.Index.The example assigns it to a captured group so that the starting position of the duplicate word can be retrieved from the Match.Index property.
\W Estabeleça a correspondência com caracteres que não compõem palavras, como espaços em branco e pontuação.Match a non-word character, including white space and punctuation. Isso impede a correspondência de um padrão de expressão regular com uma expressão que começa com a palavra do primeiro grupo capturado.This prevents the regular expression pattern from matching a word that starts with the word from the first captured group.

Subexpressões Correspondentes NomeadasNamed Matched Subexpressions

O constructo de agrupamento a seguir captura uma subexpressão correspondente e permite acessá-la usando seu nome ou número:The following grouping construct captures a matched subexpression and lets you access it by name or by number:

(?<name>subexpression)

ou:or:

(?'name'subexpression)

em que name é um nome de grupo válido e subexpression é qualquer padrão de expressão regular válido.where name is a valid group name, and subexpression is any valid regular expression pattern. name não deve conter caracteres de pontuação nem começar com um número.name must not contain any punctuation characters and cannot begin with a number.

Observação

Se o parâmetro RegexOptions de um padrão de expressão regular que corresponde ao método inclui o sinalizador RegexOptions.ExplicitCapture ou se a opção n é aplicada a essa subexpressão (consulte Opções de grupo mais adiante neste tópico), a única forma de capturar uma subexpressão é atribuir nomes explícitos a grupos de captura.If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression (see Group options later in this topic), the only way to capture a subexpression is to explicitly name capturing groups.

Você pode acessar grupos capturados nomeados destas formas:You can access named captured groups in the following ways:

  • Usando o constructo de referência inversa nomeado na expressão regular.By using the named backreference construct within the regular expression. A subexpressão coincidente é referenciada na mesma expressão regular usando a sintaxe \k<name>, em que name é o nome da subexpressão capturada.The matched subexpression is referenced in the same regular expression by using the syntax \k<name>, where name is the name of the captured subexpression.

  • Usando o constructo de referência inversa na expressão regular.By using the backreference construct within the regular expression. A subexpressão correspondente é referenciada na mesma expressão regular usando a sintaxe \number, em que number é o número ordinal da subexpressão capturada.The matched subexpression is referenced in the same regular expression by using the syntax \number, where number is the ordinal number of the captured subexpression. As subexpressões correspondentes nomeadas são numeradas em ordem de sequência, da esquerda da direita, após as subexpressões correspondentes.Named matched subexpressions are numbered consecutively from left to right after matched subexpressions.

  • Ao usar a sequência de substituição ${name} em uma chamada de método Regex.Replace ou Match.Result, em que name é o nome da subexpressão capturada.By using the ${name} replacement sequence in a Regex.Replace or Match.Result method call, where name is the name of the captured subexpression.

  • Ao usar a sequência de substituição $number em uma chamada de método Regex.Replace ou Match.Result, em que number é o número ordinal da subexpressão capturada.By using the $number replacement sequence in a Regex.Replace or Match.Result method call, where number is the ordinal number of the captured subexpression.

  • Usando de forma programática o objeto GroupCollection retornado pela propriedade Match.Groups.Programmatically, by using the GroupCollection object returned by the Match.Groups property. O membro na posição zero da coleção representa toda a correspondência da expressão regular.The member at position zero in the collection represents the entire regular expression match. Cada membro subsequente representa uma subexpressão correspondente.Each subsequent member represents a matched subexpression. Os grupos capturados nomeados são armazenados na coleção depois dos grupos capturados numerados.Named captured groups are stored in the collection after numbered captured groups.

  • De forma programática, ao fornecer o nome da subexpressão ao indexador do objeto GroupCollection (no C#) ou a sua propriedade Item[String] (no Visual Basic).Programmatically, by providing the subexpression name to the GroupCollection object's indexer (in C#) or to its Item[String] property (in Visual Basic).

Um padrão de expressão regular simples mostra como os grupos numerados (sem nome) e nomeados podem ser usados como referência de forma programática ou usando sintaxe de linguagem de expressão regular.A simple regular expression pattern illustrates how numbered (unnamed) and named groups can be referenced either programmatically or by using regular expression language syntax. A expressão regular ((?<One>abc)\d+)?(?<Two>xyz)(.*) gera os seguintes grupos de captura por número e nome.The regular expression ((?<One>abc)\d+)?(?<Two>xyz)(.*) produces the following capturing groups by number and by name. O primeiro grupo de captura (o número 0) sempre faz referência a todo o padrão.The first capturing group (number 0) always refers to the entire pattern.

NúmeroNumber NameName PadrãoPattern
00 0 (nome padrão)0 (default name) ((?<One>abc)\d+)?(?<Two>xyz)(.*)
11 1 (nome padrão)1 (default name) ((?<One>abc)\d+)
22 2 (nome padrão)2 (default name) (.*)
33 UmOne (?<One>abc)
44 DoisTwo (?<Two>xyz)

O exemplo a seguir mostra uma expressão regular que identifica palavras duplicadas e a palavra que aparece logo na sequência.The following example illustrates a regular expression that identifies duplicated words and the word that immediately follows each duplicated word. O padrão da expressão regular define duas subexpressões nomeadas: duplicateWord, que representa a palavra duplicada e nextWord, que representa a palavra que aparece logo na sequência.The regular expression pattern defines two named subexpressions: duplicateWord, which represents the duplicated word; and nextWord, which represents the word that follows the duplicated word.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)";
      string input = "He said that that was the the correct answer.";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine("A duplicate '{0}' at position {1} is followed by '{2}'.", 
                           match.Groups["duplicateWord"].Value, match.Groups["duplicateWord"].Index, 
                           match.Groups["nextWord"].Value);

   }
}
// The example displays the following output:
//       A duplicate 'that' at position 8 is followed by 'was'.
//       A duplicate 'the' at position 22 is followed by 'correct'.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)"
      Dim input As String = "He said that that was the the correct answer."
      Console.WriteLine(Regex.Matches(input, pattern, RegexOptions.IgnoreCase).Count)
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine("A duplicate '{0}' at position {1} is followed by '{2}'.", _
                           match.Groups("duplicateWord").Value, match.Groups("duplicateWord").Index, _
                           match.Groups("nextWord").Value)
      Next
   End Sub
End Module
' The example displays the following output:
'    A duplicate 'that' at position 8 is followed by 'was'.
'    A duplicate 'the' at position 22 is followed by 'correct'.

Este é o padrão da expressão regular:The regular expression pattern is as follows:

(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)

A tabela a seguir mostra como a expressão regular é interpretada.The following table shows how the regular expression is interpreted.

PadrãoPattern DescriçãoDescription
(?<duplicateWord>\w+) Corresponde a um ou mais caracteres de palavra.Match one or more word characters. Atribua um nome ao grupo de captura duplicateWord.Name this capturing group duplicateWord.
\s Corresponde a um caractere de espaço em branco.Match a white-space character.
\k<duplicateWord> Estabeleça a correspondência com o grupo de captura chamado duplicateWord.Match the string from the captured group that is named duplicateWord.
\W Estabeleça a correspondência com caracteres que não compõem palavras, como espaços em branco e pontuação.Match a non-word character, including white space and punctuation. Isso impede a correspondência de um padrão de expressão regular com uma expressão que começa com a palavra do primeiro grupo capturado.This prevents the regular expression pattern from matching a word that starts with the word from the first captured group.
(?<nextWord>\w+) Corresponde a um ou mais caracteres de palavra.Match one or more word characters. Atribua um nome ao grupo de captura nextWord.Name this capturing group nextWord.

Observe que o nome de um grupo pode ser repetido em uma expressão regular.Note that a group name can be repeated in a regular expression. Por exemplo, é possível que mais de um grupo seja nomeado como digit, como mostra o exemplo a seguir.For example, it is possible for more than one group to be named digit, as the following example illustrates. No caso de nomes duplicados, o valor do objeto Group é determinado pela última captura bem-sucedida na cadeia de caracteres de entrada.In the case of duplicate names, the value of the Group object is determined by the last successful capture in the input string. Além disso, a CaptureCollection é preenchida com informações sobre cada captura exatamente como seria se o nome do grupo não fosse duplicado.In addition, the CaptureCollection is populated with information about each capture just as it would be if the group name was not duplicated.

No exemplo a seguir, a expressão regular \D+(?<digit>\d+)\D+(?<digit>\d+)? inclui duas ocorrências de um grupo chamado digit.In the following example, the regular expression \D+(?<digit>\d+)\D+(?<digit>\d+)? includes two occurrences of a group named digit. O primeiro grupo chamado digit captura um ou mais caracteres de dígito.The first digit named group captures one or more digit characters. O primeiro grupo chamado digit captura zero ou uma ocorrência de um ou mais caracteres de dígito.The second digit named group captures either zero or one occurrence of one or more digit characters. Como a saída do exemplo apresentado mostra, se o segundo grupo de captura corresponder ao texto com êxito, o valor desse texto definirá o valor do objeto Group.As the output from the example shows, if the second capturing group successfully matches text, the value of that text defines the value of the Group object. Se o segundo grupo de captura não corresponder à cadeia de caracteres de entrada, o valor da última correspondência bem-sucedida definirá o valor do objeto Group.If the second capturing group cannot does not match the input string, the value of the last successful match defines the value of the Group object.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      String pattern = @"\D+(?<digit>\d+)\D+(?<digit>\d+)?";
      String[] inputs = { "abc123def456", "abc123def" };
      foreach (var input in inputs) {
         Match m = Regex.Match(input, pattern);
         if (m.Success) {
            Console.WriteLine("Match: {0}", m.Value);
            for (int grpCtr = 1; grpCtr < m.Groups.Count; grpCtr++) {
               Group grp = m.Groups[grpCtr];
               Console.WriteLine("Group {0}: {1}", grpCtr, grp.Value);
               for (int capCtr = 0; capCtr < grp.Captures.Count; capCtr++)
                  Console.WriteLine("   Capture {0}: {1}", capCtr,
                                    grp.Captures[capCtr].Value);
            }
         }
         else {
            Console.WriteLine("The match failed.");
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       Match: abc123def456
//       Group 1: 456
//          Capture 0: 123
//          Capture 1: 456
//
//       Match: abc123def
//       Group 1: 123
//          Capture 0: 123
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\D+(?<digit>\d+)\D+(?<digit>\d+)?"
      Dim inputs() As String = { "abc123def456", "abc123def" }
      For Each input As String In inputs
         Dim m As Match = Regex.Match(input, pattern)
         If m.Success Then
            Console.WriteLine("Match: {0}", m.Value)
            For grpCtr As Integer = 1 to m.Groups.Count - 1
               Dim grp As Group = m.Groups(grpCtr)
               Console.WriteLine("Group {0}: {1}", grpCtr, grp.Value)
               For capCtr As Integer = 0 To grp.Captures.Count - 1
                  Console.WriteLine("   Capture {0}: {1}", capCtr,
                                    grp.Captures(capCtr).Value)
               Next
            Next
         Else
            Console.WriteLine("The match failed.")
         End If
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'       Match: abc123def456
'       Group 1: 456
'          Capture 0: 123
'          Capture 1: 456
'
'       Match: abc123def
'       Group 1: 123
'          Capture 0: 123

A tabela a seguir mostra como a expressão regular é interpretada.The following table shows how the regular expression is interpreted.

PadrãoPattern DescriçãoDescription
\D+ Corresponder a um ou mais caracteres de dígito não decimal.Match one or more non-decimal digit characters.
(?<digit>\d+) Corresponder a um ou mais caracteres de dígito decimal.Match one or more decimal digit characters. Atribuir a correspondência ao grupo chamado digit.Assign the match to the digit named group.
\D+ Corresponder a um ou mais caracteres de dígito não decimal.Match one or more non-decimal digit characters.
(?<digit>\d+)? Faz a correspondência de zero ou uma ocorrência de um período seguido por um ou mais caracteres de dígito decimal.Match zero or one occurrence of one or more decimal digit characters. Atribuir a correspondência ao grupo chamado digit.Assign the match to the digit named group.

Definições de grupo de balanceamentoBalancing Group Definitions

Uma definição de grupo de balanceamento exclui a definição de um grupo definido anteriormente e armazena, no grupo atual, o intervalo entre o grupo definido anteriormente e o atual.A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. Esse constructo de agrupamento tem o seguinte formato:This grouping construct has the following format:

(?<name1-name2>subexpression)

ou:or:

(?'name1-name2' subexpression)

em que name1 é o grupo atual (opcional), name2 é um grupo definido anteriormente e subexpression é qualquer padrão de expressão regular válido.where name1 is the current group (optional), name2 is a previously defined group, and subexpression is any valid regular expression pattern. A definição de grupo de balanceamento exclui a definição de name2 e armazena o intervalo entre name2 e name1 em name1.The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. Se nenhum grupo name2 for definido, a correspondência retrocede.If no name2 group is defined, the match backtracks. Como a exclusão da última definição de name2 revela a definição anterior de name2, essa construção permite que você use a pilha de capturas para o grupo name2 como um contador, a fim de registrar construções aninhadas, como parênteses e colchetes.Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.

A definição de grupo de balanceamento usa name2 como pilha.The balancing group definition uses name2 as a stack. O caractere inicial de cada construção aninhada é colocado no grupo e em sua coleção Group.Captures.The beginning character of each nested construct is placed in the group and in its Group.Captures collection. Quando o caractere de fechamento passa pela correspondência, seu caractere de abertura é removido do grupo e a coleção Captures diminui em um.When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. Depois da correspondência dos caracteres de abertura e fechamento de todas as construções aninhadas, name2 fica vazio.After the opening and closing characters of all nested constructs have been matched, name2 is empty.

Observação

Depois de modificar a expressão regular do exemplo a seguir para usar o caractere de abertura e fechamento adequado de um constructo aninhado, você pode usá-lo para gerenciar a maioria dos constructo aninhados, como expressões matemáticas ou linhas do código do programa que incluem diversas chamadas de método aninhado.After you modify the regular expression in the following example to use the appropriate opening and closing character of a nested construct, you can use it to handle most nested constructs, such as mathematical expressions or lines of program code that include multiple nested method calls.

O exemplo a seguir usa uma definição de grupo de balanceamento para estabelecer a correspondência entre os sinais de menor e maior (<>) em uma cadeia de caracteres de entrada.The following example uses a balancing group definition to match left and right angle brackets (<>) in an input string. O exemplo define dois grupos nomeados, Open e Close, que são usados como pilha para acompanhar a correspondência entre esses sinais.The example defines two named groups, Open and Close, that are used like a stack to track matching pairs of angle brackets. Cada sinal de menor capturado é enviado para a coleção da captura do grupo Open e cada sinal de maior capturado é enviado para a coleção de captura do grupo Close.Each captured left angle bracket is pushed into the capture collection of the Open group, and each captured right angle bracket is pushed into the capture collection of the Close group. A definição do grupo de balanceamento assegura que há um sinal de maior para cada sinal de menor.The balancing group definition ensures that there is a matching right angle bracket for each left angle bracket. Caso não haja, o subpadrão final (?(Open)(?!)), só será avaliado se o grupo Open não estiver vazio, ou seja, se todas as construções aninhadas não tiverem sido fechadas.If there is not, the final subpattern, (?(Open)(?!)), is evaluated only if the Open group is not empty (and, therefore, if all nested constructs have not been closed). Se o subpadrão final for avaliado, a correspondência falha, porque o subpadrão (?!) é uma asserção lookahead negativa de largura zero que sempre falha.If the final subpattern is evaluated, the match fails, because the (?!) subpattern is a zero-width negative lookahead assertion that always fails.

using System;
using System.Text.RegularExpressions;

class Example
{
   public static void Main() 
   {
      string pattern = "^[^<>]*" +
                       "(" + 
                       "((?'Open'<)[^<>]*)+" +
                       "((?'Close-Open'>)[^<>]*)+" +
                       ")*" +
                       "(?(Open)(?!))$";
      string input = "<abc><mno<xyz>>";

      Match m = Regex.Match(input, pattern);
      if (m.Success == true)
      {
         Console.WriteLine("Input: \"{0}\" \nMatch: \"{1}\"", input, m);
         int grpCtr = 0;
         foreach (Group grp in m.Groups)
         {
            Console.WriteLine("   Group {0}: {1}", grpCtr, grp.Value);
            grpCtr++;
            int capCtr = 0;
            foreach (Capture cap in grp.Captures)
            {            
                Console.WriteLine("      Capture {0}: {1}", capCtr, cap.Value);
                capCtr++;
            }
          }
      }
      else
      {
         Console.WriteLine("Match failed.");
      }   
    }
}
// The example displays the following output:
//    Input: "<abc><mno<xyz>>"
//    Match: "<abc><mno<xyz>>"
//       Group 0: <abc><mno<xyz>>
//          Capture 0: <abc><mno<xyz>>
//       Group 1: <mno<xyz>>
//          Capture 0: <abc>
//          Capture 1: <mno<xyz>>
//       Group 2: <xyz
//          Capture 0: <abc
//          Capture 1: <mno
//          Capture 2: <xyz
//       Group 3: >
//          Capture 0: >
//          Capture 1: >
//          Capture 2: >
//       Group 4:
//       Group 5: mno<xyz>
//          Capture 0: abc
//          Capture 1: xyz
//          Capture 2: mno<xyz>
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main() 
        Dim pattern As String = "^[^<>]*" & _
                                "(" + "((?'Open'<)[^<>]*)+" & _
                                "((?'Close-Open'>)[^<>]*)+" + ")*" & _
                                "(?(Open)(?!))$"
        Dim input As String = "<abc><mno<xyz>>"
        Dim rgx AS New Regex(pattern)'
        Dim m As Match = Regex.Match(input, pattern)
        If m.Success Then
            Console.WriteLine("Input: ""{0}"" " & vbCrLf & "Match: ""{1}""", _
                               input, m)
            Dim grpCtr As Integer = 0
            For Each grp As Group In m.Groups
               Console.WriteLine("   Group {0}: {1}", grpCtr, grp.Value)
               grpCtr += 1
               Dim capCtr As Integer = 0
               For Each cap As Capture In grp.Captures            
                  Console.WriteLine("      Capture {0}: {1}", capCtr, cap.Value)
                  capCtr += 1
               Next
            Next
        Else
            Console.WriteLine("Match failed.")
        End If
    End Sub
End Module  
' The example displays the following output:
'       Input: "<abc><mno<xyz>>"
'       Match: "<abc><mno<xyz>>"
'          Group 0: <abc><mno<xyz>>
'             Capture 0: <abc><mno<xyz>>
'          Group 1: <mno<xyz>>
'             Capture 0: <abc>
'             Capture 1: <mno<xyz>>
'          Group 2: <xyz
'             Capture 0: <abc
'             Capture 1: <mno
'             Capture 2: <xyz
'          Group 3: >
'             Capture 0: >
'             Capture 1: >
'             Capture 2: >
'          Group 4:
'          Group 5: mno<xyz>
'             Capture 0: abc
'             Capture 1: xyz
'             Capture 2: mno<xyz>

O padrão da expressão regular é:The regular expression pattern is:

^[^<>]*(((?'Open'<)[^<>]*)+((?'Close-Open'>)[^<>]*)+)*(?(Open)(?!))$

A expressão regular é interpretada da seguinte forma:The regular expression is interpreted as follows:

PadrãoPattern DescriçãoDescription
^ Começa no início da cadeia de caracteres.Begin at the start of the string.
[^<>]* Corresponde a zero ou mais caracteres que não são sinais de menor nem maior.Match zero or more characters that are not left or right angle brackets.
(?'Open'<) Corresponde a um sinal de menor e o atribui a um grupo nomeado Open.Match a left angle bracket and assign it to a group named Open.
[^<>]* Corresponde a zero ou mais caracteres que não são sinais de menor nem maior.Match zero or more characters that are not left or right angle brackets.
((?'Open'<)[^<>]*)+ Corresponde uma ou mais ocorrências de um sinal de menor, seguida por zero ou mais caracteres que não são sinais de menor ou maior.Match one or more occurrences of a left angle bracket followed by zero or more characters that are not left or right angle brackets. Este é o segundo grupo de captura.This is the second capturing group.
(?'Close-Open'>) Corresponde a um sinal de maior, atribui a subcadeia de caracteres entre o grupo Open e o grupo atual ao grupo Close e exclui a definição do grupo Open.Match a right angle bracket, assign the substring between the Open group and the current group to the Close group, and delete the definition of the Open group.
[^<>]* Corresponde a zero ou mais ocorrências de caracteres que não são sinais de menor ou maior.Match zero or more occurrences of any character that is neither a left nor a right angle bracket.
((?'Close-Open'>)[^<>]*)+ Corresponde a uma ou mais ocorrências de sinal de menor seguidas por zero ou mais ocorrências de qualquer caractere que não seja um sinal de menor ou maior.Match one or more occurrences of a right angle bracket, followed by zero or more occurrences of any character that is neither a left nor a right angle bracket. Ao estabelecer a correspondência de um sinal de maior, atribua a subcadeia de caracteres entre o grupo Open e o grupo atual ao grupo Close e exclua a definição do grupo Open.When matching the right angle bracket, assign the substring between the Open group and the current group to the Close group, and delete the definition of the Open group. Este é o terceiro grupo de captura.This is the third capturing group.
(((?'Open'<)[^<>]*)+((?'Close-Open'>)[^<>]*)+)* Corresponde a zero ou mais ocorrências do seguinte padrão: uma ou mais ocorrências de sinal de menor seguidas por zero ou mais ocorrências de qualquer caractere que não seja um sinal de menor ou maior, seguida por uma ou mais ocorrências de sinal de maior, seguida por zero ou mais ocorrências de caracteres que não sejam sinais de menor ou maior.Match zero or more occurrences of the following pattern: one or more occurrences of a left angle bracket, followed by zero or more non-angle bracket characters, followed by one or more occurrences of a right angle bracket, followed by zero or more occurrences of non-angle brackets. Ao estabelecer a correspondência de um sinal de maior, exclua a definição do grupo Open e atribua a subcadeia entre o grupo Open e o grupo atual ao grupo Close.When matching the right angle bracket, delete the definition of the Open group, and assign the substring between the Open group and the current group to the Close group. Este é o primeiro grupo de captura.This is the first capturing group.
(?(Open)(?!)) Se o grupo Open existir, abandone a correspondência se for possível estabelecer a correspondência de uma cadeia de caracteres vazia, mas não avance a posição do mecanismo de expressão regular na cadeia de caracteres.If the Open group exists, abandon the match if an empty string can be matched, but do not advance the position of the regular expression engine in the string. Trata-se de uma asserção lookahead negativa de largura zero.This is a zero-width negative lookahead assertion. Como sempre há cadeias de caracteres vazias presentes em cadeias de caracteres de entrada, essa correspondência sempre falha.Because an empty string is always implicitly present in an input string, this match always fails. A falha nessa correspondência indica que os sinais de menor e maior não estão balanceados.Failure of this match indicates that the angle brackets are not balanced.
$ Corresponder ao final da cadeia de caracteres de entrada.Match the end of the input string.

A subexpressão final, (?(Open)(?!)), indica se a construção de aninhamento da cadeia de caracteres de entrada está balanceada corretamente (por exemplo, se cada sinal de maior corresponde a um sinal de menor).The final subexpression, (?(Open)(?!)), indicates whether the nesting constructs in the input string are properly balanced (for example, whether each left angle bracket is matched by a right angle bracket). Ela usa a correspondência condicional com base em um grupo capturado válido; para obter mais informações, veja Construções de alternância.It uses conditional matching based on a valid captured group; for more information, see Alternation Constructs. Se o grupo Open for definido, o mecanismo de expressão regular tenta estabelecer a correspondência da subexpressão (?!) na cadeia de caracteres de saída.If the Open group is defined, the regular expression engine attempts to match the subexpression (?!) in the input string. O grupo Open só deve ser definido se as construções de aninhamento não estiverem balanceadas.The Open group should be defined only if nesting constructs are unbalanced. Portanto, o padrão para correspondência na cadeia de caracteres de entrada sempre deve fazer com que a correspondência falhe.Therefore, the pattern to be matched in the input string should be one that always causes the match to fail. Nesse caso, (?!) é uma asserção lookahead negativa de largura zero que sempre falha, porque sempre há cadeias de caracteres vazias presentes na próxima posição da cadeia de caracteres de entrada.In this case, (?!) is a zero-width negative lookahead assertion that always fails, because an empty string is always implicitly present at the next position in the input string.

No exemplo, o mecanismo da expressão regular avalia a cadeia de caracteres de entrada "<abc><mno<xyz>>" como mostra a tabela a seguir.In the example, the regular expression engine evaluates the input string "<abc><mno<xyz>>" as shown in the following table.

EtapaStep PadrãoPattern ResultadoResult
11 ^ Começa a correspondência no início da cadeia de caracteres de entradaStarts the match at the beginning of the input string
22 [^<>]* Procura caracteres que não sejam sinais de menor e maior antes do sinal de menor e não encontra correspondências.Looks for non-angle bracket characters before the left angle bracket;finds no matches.
33 (((?'Open'<) Corresponde ao sinal de menor em "<abc>" e o atribui ao grupo Open.Matches the left angle bracket in "<abc>" and assigns it to the Open group.
44 [^<>]* Corresponde a "abc".Matches "abc".
55 )+ "<abc" é o valor do segundo grupo capturado."<abc" is the value of the second captured group.

O próximo caractere na cadeia de caracteres de entrada não é um sinal de menor. Por isso, o mecanismo de expressão regular não volta para o subpadrão (?'Open'<)[^<>]*).The next character in the input string is not a left angle bracket, so the regular expression engine does not loop back to the (?'Open'<)[^<>]*) subpattern.
66 ((?'Close-Open'>) Corresponde ao sinal de maior de "<abc>", atribui "abc", que é a subcadeia de caracteres entre o grupo Open e o sinal de menor, para o grupo Close e exclui o valor atual ("<") do grupo Open, deixando-o vazio.Matches the right angle bracket in "<abc>", assigns "abc", which is the substring between the Open group and the right angle bracket, to the Close group, and deletes the current value ("<") of the Open group, leaving it empty.
77 [^<>]* Procura caracteres que não sejam sinais de menor e maior depois do sinal de maior e não encontra correspondências.Looks for non-angle bracket characters after the right angle bracket; finds no matches.
88 )+ O valor do terceiro grupo capturado é ">".The value of the third captured group is ">".

O próximo caractere na cadeia de caracteres de entrada não é um sinal de maior. Por isso, o mecanismo de expressão regular não volta para o subpadrão ((?'Close-Open'>)[^<>]*).The next character in the input string is not a right angle bracket, so the regular expression engine does not loop back to the ((?'Close-Open'>)[^<>]*) subpattern.
99 )* O valor do primeiro grupo capturado é "<abc>".The value of the first captured group is "<abc>".

O próximo caractere na cadeia de caracteres de entrada é um sinal de menor. Por isso, o mecanismo de expressão regular volta para o subpadrão (((?'Open'<).The next character in the input string is a left angle bracket, so the regular expression engine loops back to the (((?'Open'<) subpattern.
1010 (((?'Open'<) Corresponde ao sinal de menor em "<mno" e o atribui ao grupo Open.Matches the left angle bracket in "<mno" and assigns it to the Open group. Agora, sua coleção Group.Captures tem um único valor, "<".Its Group.Captures collection now has a single value, "<".
1111 [^<>]* Corresponde a "mno".Matches "mno".
1212 )+ "<mno" é o valor do segundo grupo capturado."<mno" is the value of the second captured group.

O próximo caractere na cadeia de caracteres de entrada é um sinal de menor. Por isso, o mecanismo de expressão regular volta para o subpadrão (?'Open'<)[^<>]*).The next character in the input string is an left angle bracket, so the regular expression engine loops back to the (?'Open'<)[^<>]*) subpattern.
1313 (((?'Open'<) Corresponde ao sinal de menor em "<xyz>" e o atribui ao grupo Open.Matches the left angle bracket in "<xyz>" and assigns it to the Open group. Agora, a coleção Group.Captures do grupo Open inclui duas capturas: o sinal de menor de "<mno" e o sinal de menor de "<xyz>".The Group.Captures collection of the Open group now includes two captures: the left angle bracket from "<mno", and the left angle bracket from "<xyz>".
1414 [^<>]* Corresponde a "xyz".Matches "xyz".
1515 )+ "<xyz" é o valor do segundo grupo capturado."<xyz" is the value of the second captured group.

O próximo caractere na cadeia de caracteres de entrada não é um sinal de menor. Por isso, o mecanismo de expressão regular não volta para o subpadrão (?'Open'<)[^<>]*).The next character in the input string is not a left angle bracket, so the regular expression engine does not loop back to the (?'Open'<)[^<>]*) subpattern.
1616 ((?'Close-Open'>) Corresponde ao sinal de maior em "<xyz>".Matches the right angle bracket in "<xyz>". "xyz" atribui a subcadeia de caracteres entre o grupo Open e o sinal de maior ao grupo Close e exclui o valor atual do grupo Open."xyz", assigns the substring between the Open group and the right angle bracket to the Close group, and deletes the current value of the Open group. O valor da captura anterior (o sinal de menor em "<mno") torna-se o valor atual do grupo Open.The value of the previous capture (the left angle bracket in "<mno") becomes the current value of the Open group. Agora, a coleção Captures do grupo Open inclui uma única captura: o sinal de menor de "<xyz>".The Captures collection of the Open group now includes a single capture, the left angle bracket from "<xyz>".
1717 [^<>]* Procura caracteres que não sejam sinais de menor e maior e não encontra correspondências.Looks for non-angle bracket characters; finds no matches.
1818 )+ O valor do terceiro grupo capturado é ">".The value of the third captured group is ">".

O próximo caractere na cadeia de caracteres de entrada é um sinal de maior. Por isso, o mecanismo de expressão regular volta para o subpadrão ((?'Close-Open'>)[^<>]*).The next character in the input string is a right angle bracket, so the regular expression engine loops back to the ((?'Close-Open'>)[^<>]*) subpattern.
1919 ((?'Close-Open'>) Corresponde ao sinal de maior final de "xyz>>", atribui "mno<xyz>" (a subcadeia de caracteres entre o grupo Open e o sinal de maior) ao grupo Close e exclui o valor atual do grupo Open.Matches the final right angle bracket in "xyz>>", assigns "mno<xyz>" (the substring between the Open group and the right angle bracket) to the Close group, and deletes the current value of the Open group. Agora, o grupo Open está vazio.The Open group is now empty.
2020 [^<>]* Procura caracteres que não sejam sinais de menor e maior e não encontra correspondências.Looks for non-angle bracket characters; finds no matches.
2121 )+ O valor do terceiro grupo capturado é ">".The value of the third captured group is ">".

O próximo caractere na cadeia de caracteres de entrada não é um sinal de maior. Por isso, o mecanismo de expressão regular não volta para o subpadrão ((?'Close-Open'>)[^<>]*).The next character in the input string is not a right angle bracket, so the regular expression engine does not loop back to the ((?'Close-Open'>)[^<>]*) subpattern.
2222 )* O valor do primeiro grupo capturado é "<mno<xyz>>".The value of the first captured group is "<mno<xyz>>".

O próximo caractere na cadeia de caracteres de entrada não é um sinal de menor. Por isso, o mecanismo de expressão regular não volta para o subpadrão (((?'Open'<).The next character in the input string is not a left angle bracket, so the regular expression engine does not loop back to the (((?'Open'<) subpattern.
2323 (?(Open)(?!)) O grupo Open não é definido. Por isso, não há tentativa de correspondência.The Open group is not defined, so no match is attempted.
2424 $ Corresponde ao final da cadeia de caracteres de entrada.Matches the end of the input string.

Grupos de Não CapturaNoncapturing Groups

O constructo de grupo a seguir não captura a subcadeia de caracteres correspondente a uma subexpressão:The following grouping construct does not capture the substring that is matched by a subexpression:

(?:subexpression)

em que subexpression é qualquer padrão de expressão regular válido.where subexpression is any valid regular expression pattern. O constructo de grupo de não captura geralmente é usada quando um quantificador é aplicado a um grupo, mas as subcadeias de caracteres capturadas pelo grupo não são úteis.The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest.

Observação

Se uma expressão regular inclui constructos aninhados de agrupamento, um constructo de grupo de não captura externo não se aplica às construções aninhadas internas de grupo.If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs.

O exemplo a seguir mostra uma expressão regular que inclui grupos de não captura.The following example illustrates a regular expression that includes noncapturing groups. O resultado não inclui grupos capturados.Note that the output does not include any captured groups.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(?:\b(?:\w+)\W*)+\.";
      string input = "This is a short sentence.";
      Match match = Regex.Match(input, pattern);
      Console.WriteLine("Match: {0}", match.Value);
      for (int ctr = 1; ctr < match.Groups.Count; ctr++)
         Console.WriteLine("   Group {0}: {1}", ctr, match.Groups[ctr].Value);
   }
}
// The example displays the following output:
//       Match: This is a short sentence.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(?:\b(?:\w+)\W*)+\."
      Dim input As String = "This is a short sentence."
      Dim match As Match = Regex.Match(input, pattern)
      Console.WriteLine("Match: {0}", match.Value)
      For ctr As Integer = 1 To match.Groups.Count - 1
         Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       Match: This is a short sentence.

A expressão regular (?:\b(?:\w+)\W*)+\. corresponde a uma sentença terminada por um ponto final.The regular expression (?:\b(?:\w+)\W*)+\. matches a sentence that is terminated by a period. Como a expressão regular concentra-se em sentenças, e não em palavras, as construções de agrupamento são usadas apenas como quantificadores.Because the regular expression focuses on sentences and not on individual words, grouping constructs are used exclusively as quantifiers. O padrão da expressão regular é interpretado conforme a tabela a seguir.The regular expression pattern 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 at a word boundary.
(?:\w+) Corresponde a um ou mais caracteres de palavra.Match one or more word characters. Não atribui o texto coincidente a um grupo capturado.Do not assign the matched text to a captured group.
\W* Corresponde a zero ou mais caracteres que não compõem palavras.Match zero or more non-word characters.
(?:\b(?:\w+)\W*)+ Corresponde ao padrão de um ou mais caracteres de palavra que começam com um limite de palavra, seguido por zero ou um espaço em branco uma ou mais vezes.Match the pattern of one or more word characters starting at a word boundary, followed by zero or more non-word characters, one or more times. Não atribui o texto coincidente a um grupo capturado.Do not assign the matched text to a captured group.
\. Corresponde a um ponto final.Match a period.

Opções de GrupoGroup Options

O constructo de agrupamento a seguir aplica ou desabilita as opções especificadas em uma subexpressão:The following grouping construct applies or disables the specified options within a subexpression:

(?imnsx-imnsx: subexpressão )(?imnsx-imnsx: subexpression )

em que subexpression é qualquer padrão de expressão regular válido.where subexpression is any valid regular expression pattern. Por exemplo, (?i-s:) ativa a diferenciação de maiúsculas e minúsculas e desabilita o modo de linha única.For example, (?i-s:) turns on case insensitivity and disables single-line mode. Para saber mais sobre as opções embutidas que você pode especificar, veja Opções de expressões regulares.For more information about the inline options you can specify, see Regular Expression Options.

Observação

Você pode especificar opções que se aplicam a toda uma expressão regular, em vez de a uma subexpressão, usando um construtor de classe System.Text.RegularExpressions.Regex ou método estático.You can specify options that apply to an entire regular expression rather than a subexpression by using a System.Text.RegularExpressions.Regex class constructor or a static method. Você também pode especificar opções embutidas que são aplicadas após um ponto específico de uma expressão regular, usando o constructo de linguagem (?imnsx-imnsx).You can also specify inline options that apply after a specific point in a regular expression by using the (?imnsx-imnsx) language construct.

O constructo de opções de grupo não é um grupo de captura.The group options construct is not a capturing group. Ou seja, embora todas as porções de uma cadeia de caracteres que são capturadas pela subexpressão sejam incluídas na correspondência, elas não são incluídas em grupos capturados, nem usadas para preencher o objeto GroupCollection.That is, although any portion of a string that is captured by subexpression is included in the match, it is not included in a captured group nor used to populate the GroupCollection object.

Por exemplo, a expressão regular \b(?ix: d \w+)\s no exemplo a seguir usa opções embutidas em um constructo de agrupamento para habilitar a correspondência sem diferenciação de maiúsculas e minúsculas e ignorar os espaços em branco do padrão, ao identificar todas as palavras que começam com a letra "d".For example, the regular expression \b(?ix: d \w+)\s in the following example uses inline options in a grouping construct to enable case-insensitive matching and ignore pattern white space in identifying all words that begin with the letter "d". 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
\b Começa a correspondência em um limite de palavra.Begin the match at a word boundary.
(?ix: d \w+) Usa a correspondência sem diferenciar letras maiúsculas e minúsculas e ignora espaços em branco nesse padrão e corresponde um "d" seguido por um ou mais caracteres que compõem palavras.Using case-insensitive matching and ignoring white space in this pattern, match a "d" followed by one or more word characters.
\s Corresponde a um caractere de espaço em branco.Match a white-space character.
string pattern = @"\b(?ix: d \w+)\s";
string input = "Dogs are decidedly good pets.";

foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
// The example displays the following output:
//    'Dogs // found at index 0.
//    'decidedly // found at index 9.      
Dim pattern As String = "\b(?ix: d \w+)\s"
Dim input As String = "Dogs are decidedly good pets."

For Each match As Match In Regex.Matches(input, pattern)
   Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'    'Dogs ' found at index 0.
'    'decidedly ' found at index 9.      

Asserções Lookahead Positivas de Largura ZeroZero-Width Positive Lookahead Assertions

O constructo de agrupamento a seguir define uma asserção lookahead positiva de largura zero:The following grouping construct defines a zero-width positive lookahead assertion:

(?= subexpressão )(?= subexpression )

em que subexpression é qualquer padrão de expressão regular.where subexpression is any regular expression pattern. Para que a correspondência seja executada com êxito, a cadeia de caracteres de entrada deve corresponder ao padrão de expressão regular na subexpression, embora a subcadeia de caracteres com a qual a correspondência foi estabelecida não conste no resultado.For a match to be successful, the input string must match the regular expression pattern in subexpression, although the matched substring is not included in the match result. A asserção lookahead positiva de largura zero não retrocede.A zero-width positive lookahead assertion does not backtrack.

Geralmente, as asserções desse tipo podem ser encontradas no final de um padrão de expressão regular.Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. Isso define uma subcadeia de caracteres que deve estar presente no final da cadeia de caracteres para que seja possível estabelecer a correspondência, mas que não seja incluída na correspondência.It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. Isso também é útil para evitar retrocessos em excesso.It is also useful for preventing excessive backtracking. Você pode usar asserções lookahead positivas de largura zero que garantam que um grupo capturado específico seja iniciado por um texto que corresponda a um subconjunto do padrão definido para o grupo capturado.You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. Por exemplo, se um grupo de captura corresponder a caracteres de palavras em sequência, você pode usar uma asserção desse tipo para que o primeiro caractere seja uma caractere alfabético maiúsculo.For example, if a capturing group matches consecutive word characters, you can use a zero-width positive lookahead assertion to require that the first character be an alphabetical uppercase character.

O exemplo a seguir usa asserção lookahead positiva de largura zero para estabelecer a correspondência da palavra que precede o verbo "is" na cadeia de caracteres de entrada.The following example uses a zero-width positive lookahead assertion to match the word that precedes the verb "is" in the input string.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+(?=\sis\b)";
      string[] inputs = { "The dog is a Malamute.", 
                          "The island has beautiful birds.", 
                          "The pitch missed home plate.", 
                          "Sunday is a weekend day." };

      foreach (string input in inputs)
      {
         Match match = Regex.Match(input, pattern);
         if (match.Success)
            Console.WriteLine("'{0}' precedes 'is'.", match.Value);
         else
            Console.WriteLine("'{0}' does not match the pattern.", input); 
      }
   }
}
// The example displays the following output:
//    'dog' precedes 'is'.
//    'The island has beautiful birds.' does not match the pattern.
//    'The pitch missed home plate.' does not match the pattern.
//    'Sunday' precedes 'is'.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+(?=\sis\b)"
      Dim inputs() As String = { "The dog is a Malamute.", _
                                 "The island has beautiful birds.", _
                                 "The pitch missed home plate.", _
                                 "Sunday is a weekend day." }

      For Each input As String In inputs
         Dim match As Match = Regex.Match(input, pattern)
         If match.Success Then
            Console.WriteLine("'{0}' precedes 'is'.", match.Value)
         Else
            Console.WriteLine("'{0}' does not match the pattern.", input) 
         End If     
      Next
   End Sub
End Module
' The example displays the following output:
'       'dog' precedes 'is'.
'       'The island has beautiful birds.' does not match the pattern.
'       'The pitch missed home plate.' does not match the pattern.
'       'Sunday' precedes 'is'.

A expressão regular \b\w+(?=\sis\b) é interpretada conforme mostrado na tabela a seguir.The regular expression \b\w+(?=\sis\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 at a word boundary.
\w+ Corresponde a um ou mais caracteres de palavra.Match one or more word characters.
(?=\sis\b) Determina se os caracteres que compõem palavras são seguidos por um caractere de espaço em branco e pela cadeia de caracteres "is", que termina com um limite de palavra.Determine whether the word characters are followed by a white-space character and the string "is", which ends on a word boundary. Nesse caso, a correspondência ocorreu com êxito.If so, the match is successful.

Asserções Lookahead Negativas de Largura ZeroZero-Width Negative Lookahead Assertions

O constructo de agrupamento a seguir define uma asserção lookahead negativa de largura zero:The following grouping construct defines a zero-width negative lookahead assertion:

(?! subexpressão )(?! subexpression )

em que subexpression é qualquer padrão de expressão regular.where subexpression is any regular expression pattern. Para que a correspondência seja executada com êxito, a cadeia de caracteres de entrada não deve corresponder ao padrão de expressão regular na subexpression, embora a cadeia de caracteres com a qual a correspondência foi estabelecida não conste no resultado.For the match to be successful, the input string must not match the regular expression pattern in subexpression, although the matched string is not included in the match result.

Geralmente, as asserções desse tipo podem ser encontradas no início ou no final de uma expressão regular.A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. No início da expressão regular, elas podem definir um padrão específico que não deve ser correspondido quando o início da expressão regular definir um padrão parecido, mas mais geral, para a correspondência.At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. Nesse caso, ela geralmente é usada para limitar o retrocesso.In this case, it is often used to limit backtracking. No final de uma expressão regular, pode definir uma subexpressão que pode não ocorrer no final de uma correspondência.At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match.

O exemplo a seguir define uma expressão regular que usa uma asserção lookahead de largura zero no início da expressão regular para fazer a correspondência de palavras que não começam com "un".The following example defines a regular expression that uses a zero-width lookahead assertion at the beginning of the regular expression to match words that do not begin with "un".

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(?!un)\w+\b";
      string input = "unite one unethical ethics use untie ultimate";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       one
//       ethics
//       use
//       ultimate
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(?!un)\w+\b"
      Dim input As String = "unite one unethical ethics use untie ultimate"
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine(match.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       one
'       ethics
'       use
'       ultimate

A expressão regular \b(?!un)\w+\b é interpretada conforme mostrado na tabela a seguir.The regular expression \b(?!un)\w+\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 at a word boundary.
(?!un) Determina se os dois caracteres seguintes são "un".Determine whether the next two characters are "un". Caso não sejam, é possível estabelecer a correspondência.If they are not, a match is possible.
\w+ Corresponde a um ou mais caracteres de palavra.Match one or more word characters.
\b Termina a correspondência em um limite de palavra.End the match at a word boundary.

O exemplo a seguir define uma expressão regular que usa uma asserção lookahead de largura zero no final da expressão regular para fazer a correspondência de palavras que não terminam com um caractere de pontuação.The following example defines a regular expression that uses a zero-width lookahead assertion at the end of the regular expression to match words that do not end with a punctuation character.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+\b(?!\p{P})";
      string input = "Disconnected, disjointed thoughts in a sentence fragment.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       disjointed
//       thoughts
//       in
//       a
//       sentence
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+\b(?!\p{P})"
      Dim input As String = "Disconnected, disjointed thoughts in a sentence fragment."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next   
   End Sub
End Module
' The example displays the following output:
'       disjointed
'       thoughts
'       in
'       a
'       sentence

A expressão regular \b\w+\b(?!\p{P}) é interpretada conforme mostrado na tabela a seguir.The regular expression \b\w+\b(?!\p{P}) 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 at a word boundary.
\w+ Corresponde a um ou mais caracteres de palavra.Match one or more word characters.
\b Termina a correspondência em um limite de palavra.End the match at a word boundary.
\p{P}) Se o caractere seguinte não for um símbolo de pontuação (por exemplo, um ponto final ou uma vírgula), a correspondência é estabelecida.If the next character is not a punctuation symbol (such as a period or a comma), the match succeeds.

Asserções Lookbehind Positivas de Largura ZeroZero-Width Positive Lookbehind Assertions

O constructo de agrupamento a seguir define uma asserção lookbehind positiva de largura zero:The following grouping construct defines a zero-width positive lookbehind assertion:

(?<= subexpressão )(?<= subexpression )

em que subexpression é qualquer padrão de expressão regular.where subexpression is any regular expression pattern. Para que a correspondência seja executada com êxito, a subexpressão deve ocorrer na cadeia de caracteres de entrada à esquerda da posição atual, embora subexpression não conste no resultado.For a match to be successful, subexpression must occur at the input string to the left of the current position, although subexpression is not included in the match result. A asserção lookbehind positiva de largura zero não retrocede.A zero-width positive lookbehind assertion does not backtrack.

As asserções lookbehind positivas de largura zero geralmente são usadas no início de expressões regulares.Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. O padrão que elas definem é uma pré-condição para a correspondência, embora não constem no resultado.The pattern that they define is a precondition for a match, although it is not a part of the match result.

Por exemplo, o exemplo a seguir estabelece a correspondência para os dois últimos dígitos de ano no século XXI (ou seja, ele requer que os dígitos "20" apareçam antes da cadeia de caracteres coincidente).For example, the following example matches the last two digits of the year for the twenty first century (that is, it requires that the digits "20" precede the matched string).

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "2010 1999 1861 2140 2009";
      string pattern = @"(?<=\b20)\d{2}\b";
      
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       10
//       09
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "2010 1999 1861 2140 2009"
      Dim pattern As String = "(?<=\b20)\d{2}\b"
      
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next      
   End Sub
End Module
' The example displays the following output:
'       10
'       09

O padrão da expressão regular (?<=\b20)\d{2}\b é interpretado conforme mostrado na tabela a seguir.The regular expression pattern (?<=\b20)\d{2}\b is interpreted as shown in the following table.

PadrãoPattern DescriçãoDescription
\d{2} Corresponde a dois dígitos decimais.Match two decimal digits.
(?<=\b20) Continua a estabelecer a correspondência se os dois dígitos decimais forem precedidos por dígitos decimais "20" em um limite de palavra.Continue the match if the two decimal digits are preceded by the decimal digits "20" on a word boundary.
\b Termina a correspondência em um limite de palavra.End the match at a word boundary.

As asserções lookbehind positivas de largura zero também são usadas para limitar o retrocesso quando o último caractere de um grupo capturado precisar ser um subconjunto de caracteres que corresponde ao padrão de expressão regular desse grupo.Zero-width positive lookbehind assertions are also used to limit backtracking when the last character or characters in a captured group must be a subset of the characters that match that group's regular expression pattern. Por exemplo, se um grupo captura todos os caracteres de palavras em sequência, você pode usar uma asserção lookbehind positivas de largura zero tipo para que o primeiro caractere seja uma letra.For example, if a group captures all consecutive word characters, you can use a zero-width positive lookbehind assertion to require that the last character be alphabetical.

Asserções Lookbehind Negativas de Largura ZeroZero-Width Negative Lookbehind Assertions

O constructo de agrupamento a seguir define uma asserção lookbehind negativa de largura zero:The following grouping construct defines a zero-width negative lookbehind assertion:

(?<! subexpressão )(?<! subexpression )

em que subexpression é qualquer padrão de expressão regular.where subexpression is any regular expression pattern. Para que a correspondência seja executada com êxito, a subexpressão não deve ocorrer na cadeia de caracteres de entrada à esquerda da posição atual.For a match to be successful, subexpression must not occur at the input string to the left of the current position. No entanto, todas as subcadeias de caracteres que não corresponderem a subexpression, não serão incluídas no resultado.However, any substring that does not match subexpression is not included in the match result.

As asserções lookbehind negativas de largura zero geralmente são usadas no início de expressões regulares.Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. O padrão definido por elas elimina uma correspondência na cadeia de caracteres seguinte.The pattern that they define precludes a match in the string that follows. Elas também são usadas para limitar o retrocesso quando o último caractere de um grupo capturado não precisar ser um ou mais caracteres que corresponde ao padrão de expressão regular desse grupo.They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. Por exemplo, se um grupo capturar todos os caracteres de palavras em sequência, você poderá usar uma asserção lookbehind positiva de largura zero para que o primeiro caractere não seja um sublinhado (_).For example, if a group captures all consecutive word characters, you can use a zero-width positive lookbehind assertion to require that the last character not be an underscore (_).

O exemplo a seguir estabelece a correspondência de data para qualquer dia da semana que não seja sábado nem domingo.The following example matches the date for any day of the week that is not a weekend (that is, that is neither Saturday nor Sunday).

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] dates = { "Monday February 1, 2010", 
                         "Wednesday February 3, 2010", 
                         "Saturday February 6, 2010", 
                         "Sunday February 7, 2010", 
                         "Monday, February 8, 2010" };
      string pattern = @"(?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b";
      
      foreach (string dateValue in dates)
      {
         Match match = Regex.Match(dateValue, pattern);
         if (match.Success)
            Console.WriteLine(match.Value);
      }      
   }
}
// The example displays the following output:
//       February 1, 2010
//       February 3, 2010
//       February 8, 2010
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim dates() As String = { "Monday February 1, 2010", _
                                "Wednesday February 3, 2010", _
                                "Saturday February 6, 2010", _
                                "Sunday February 7, 2010", _
                                "Monday, February 8, 2010" }
      Dim pattern As String = "(?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b"
      
      For Each dateValue As String In dates
         Dim match As Match = Regex.Match(dateValue, pattern)
         If match.Success Then
            Console.WriteLine(match.Value)
         End If   
      Next      
   End Sub
End Module
' The example displays the following output:
'       February 1, 2010
'       February 3, 2010
'       February 8, 2010

O padrão da expressão regular (?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b é interpretado conforme mostrado na tabela a seguir.The regular expression pattern (?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\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 at a word boundary.
\w+ Corresponde a um ou mais caracteres de palavra seguido por um espaço em branco.Match one or more word characters followed by a white-space character.
\d{1,2}, Corresponde a um ou dois dígitos decimais seguidos por uma caractere de espaço em branco e uma vírgula.Match either one or two decimal digits followed by a white-space character and a comma.
\d{4}\b Corresponde a quatro dígitos decimais e encerra a correspondência em um limite de palavra.Match four decimal digits, and end the match at a word boundary.
(?<!(Saturday|Sunday) ) Se a correspondência for precedida por algo que não seja as cadeias de caracteres "Sábado" ou "Domingo" seguidas por um espaço, a correspondência é realizada com êxito.If the match is preceded by something other than the strings "Saturday" or "Sunday" followed by a space, the match is successful.

Subexpressões sem retrocessoNonbacktracking Subexpressions

O constructo de agrupamento a seguir representa uma subexpressão sem retrocesso, também conhecida como subexpressão "greedy":The following grouping construct represents a nonbacktracking subexpression (also known as a "greedy" subexpression):

(?> subexpressão )(?> subexpression )

em que subexpression é qualquer padrão de expressão regular.where subexpression is any regular expression pattern.

Geralmente, se uma expressão regular incluir um padrão de correspondência opcional ou alternativo e a correspondência não for realizada com êxito, o mecanismo da expressão regular pode ramificar em diversas orientações para estabelecer a correspondência entre uma cadeia de caracteres de entrada e um padrão.Ordinarily, if a regular expression includes an optional or alternative matching pattern and a match does not succeed, the regular expression engine can branch in multiple directions to match an input string with a pattern. Se a correspondência não for encontrada na primeira ramificação, o mecanismo da expressão regular pode voltar ou retroceder ao ponto da primeira correspondência e tentar estabelecer a correspondência usando a segunda ramificação.If a match is not found when it takes the first branch, the regular expression engine can back up or backtrack to the point where it took the first match and attempt the match using the second branch. Esse processo pode continuar até que as tentativas se esgotem.This process can continue until all branches have been tried.

O constructo de linguagem da (?>subexpression) desabilita o retrocesso.The (?>subexpression) language construct disables backtracking. O mecanismo de expressão regular estabelece a correspondência entre o máximo de caracteres da cadeia de caracteres de entrada.The regular expression engine will match as many characters in the input string as it can. Quando não for possível estabelecer outras correspondências, ele não retrocede para tentar alternativas.When no further match is possible, it will not backtrack to attempt alternate pattern matches. Ou seja, a subexpressão corresponde somente às cadeias de caracteres que poderiam corresponder somente à subexpressão. Ela não tenta fazer a correspondência de uma cadeia de caracteres com base na subexpressão em questão e nas subexpressões seguintes.(That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.)

Essa opção é recomendada quando você sabe que o retrocesso não terá êxito.This option is recommended if you know that backtracking will not succeed. Evitar que o mecanismo de expressão regular faça pesquisas desnecessárias, melhora o desempenho.Preventing the regular expression engine from performing unnecessary searching improves performance.

O exemplo a seguir mostra como uma subexpressão sem retrocesso modifica os resultados de uma correspondência padrão.The following example illustrates how a nonbacktracking subexpression modifies the results of a pattern match. A expressão regular de retrocesso estabelece a correspondência de diversos caracteres repetidos, seguidos por outra ocorrência do mesmo caractere de um limite de palavra, mas a expressão regular sem retrocesso não faz isso.The backtracking regular expression successfully matches a series of repeated characters followed by one more occurrence of the same character on a word boundary, but the nonbacktracking regular expression does not.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "cccd.", "aaad", "aaaa" };
      string back = @"(\w)\1+.\b";
      string noback = @"(?>(\w)\1+).\b";
      
      foreach (string input in inputs)
      {
         Match match1 = Regex.Match(input, back);
         Match match2 = Regex.Match(input, noback);
         Console.WriteLine("{0}: ", input);

         Console.Write("   Backtracking : ");
         if (match1.Success)
            Console.WriteLine(match1.Value);
         else
            Console.WriteLine("No match");
         
         Console.Write("   Nonbacktracking: ");
         if (match2.Success)
            Console.WriteLine(match2.Value);
         else
            Console.WriteLine("No match");
      }
   }
}
// The example displays the following output:
//    cccd.:
//       Backtracking : cccd
//       Nonbacktracking: cccd
//    aaad:
//       Backtracking : aaad
//       Nonbacktracking: aaad
//    aaaa:
//       Backtracking : aaaa
//       Nonbacktracking: No match
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim inputs() As String = { "cccd.", "aaad", "aaaa" }
      Dim back As String = "(\w)\1+.\b"
      Dim noback As String = "(?>(\w)\1+).\b"
      
      For Each input As String In inputs
         Dim match1 As Match = Regex.Match(input, back)
         Dim match2 As Match = Regex.Match(input, noback)
         Console.WriteLine("{0}: ", input)

         Console.Write("   Backtracking : ")
         If match1.Success Then
            Console.WriteLine(match1.Value)
         Else
            Console.WriteLine("No match")
         End If
         
         Console.Write("   Nonbacktracking: ")
         If match2.Success Then
            Console.WriteLine(match2.Value)
         Else
            Console.WriteLine("No match")
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'    cccd.:
'       Backtracking : cccd
'       Nonbacktracking: cccd
'    aaad:
'       Backtracking : aaad
'       Nonbacktracking: aaad
'    aaaa:
'       Backtracking : aaaa
'       Nonbacktracking: No match

A expressão regular sem retrocesso (?>(\w)\1+).\b é definida como mostra a tabela a seguir.The nonbacktracking regular expression (?>(\w)\1+).\b is defined as shown in the following table.

PadrãoPattern DescriçãoDescription
(\w) Corresponde a um único caractere que compõe palavras e o atribui ao primeiro grupo de captura.Match a single word character and assign it to the first capturing group.
\1+ Corresponde ao valor da primeira subcadeia de caracteres de captura uma ou mais vezes.Match the value of the first captured substring one or more times.
. Corresponde a qualquer caractere.Match any character.
\b Termina a correspondência em um limite de palavra.End the match on a word boundary.
(?>(\w)\1+) Corresponde a uma ou mais ocorrências de um caractere de palavra duplicado, mas não executa o retrocesso para estabelecer a correspondência com o último caractere em um limite de palavra.Match one or more occurrences of a duplicated word character, but do not backtrack to match the last character on a word boundary.

Agrupando Constructos e Objetos de Expressão RegularesGrouping Constructs and Regular Expression Objects

As subcadeias de caracteres que correspondem a um grupo de captura de expressão regular são representadas por objetos System.Text.RegularExpressions.Group, que podem ser recuperados do objeto System.Text.RegularExpressions.GroupCollection que é retornado pela propriedade Match.Groups.Substrings that are matched by a regular expression capturing group are represented by System.Text.RegularExpressions.Group objects, which can be retrieved from the System.Text.RegularExpressions.GroupCollection object that is returned by the Match.Groups property. O objeto GroupCollection é preenchido desta forma:The GroupCollection object is populated as follows:

  • O primeiro objeto Group da coleção (o objeto de índice zero) representa a correspondência total.The first Group object in the collection (the object at index zero) represents the entire match.

  • O conjunto seguinte de objetos Group representa os grupos de captura não nomeados (numerados).The next set of Group objects represent unnamed (numbered) capturing groups. Eles aparecem na ordem em que são definidos na expressão regular, da esquerda para a direita.They appear in the order in which they are defined in the regular expression, from left to right. Os valores dos índices desses grupos variam de 1 até o número de grupos de captura não nomeados presentes na coleção.The index values of these groups range from 1 to the number of unnamed capturing groups in the collection. O índice de um determinado grupo equivale a sua referência inversa numerada.(The index of a particular group is equivalent to its numbered backreference. Para saber mais sobre referências inversas, veja Constructos de referência inversa).For more information about backreferences, see Backreference Constructs.)

  • O conjunto final de objetos Group representa os grupos de captura nomeados.The final set of Group objects represent named capturing groups. Eles aparecem na ordem em que são definidos na expressão regular, da esquerda para a direita.They appear in the order in which they are defined in the regular expression, from left to right. O valor do índice do primeiro grupo de captura nomeado é um número maior que o índice do último grupo de captura não nomeado.The index value of the first named capturing group is one greater than the index of the last unnamed capturing group. Se não houver grupos de captura não nomeados na expressão regular, o valor do índice do primeiro grupo de captura nomeado será um.If there are no unnamed capturing groups in the regular expression, the index value of the first named capturing group is one.

Se você aplicar um quantificador a um grupo de captura, as propriedades GroupCapture.Value, Capture.Index e Capture.Length do objeto refletirão a última subcadeia de caracteres capturada por um grupo de captura.If you apply a quantifier to a capturing group, the corresponding Group object's Capture.Value, Capture.Index, and Capture.Length properties reflect the last substring that is captured by a capturing group. Você pode recuperar todo o conjunto de subcadeias de caracteres capturadas por grupos que têm quantificadores do objeto CaptureCollection e que são retornados pela propriedade Group.Captures.You can retrieve a complete set of substrings that are captured by groups that have quantifiers from the CaptureCollection object that is returned by the Group.Captures property.

O exemplo a seguir esclarece a relação entre os objetos Group e Capture.The following example clarifies the relationship between the Group and Capture objects.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\b(\w+)\W+)+";
      string input = "This is a short sentence.";
      Match match = Regex.Match(input, pattern);
      Console.WriteLine("Match: '{0}'", match.Value);
      for (int ctr = 1; ctr < match.Groups.Count; ctr++)
      {
         Console.WriteLine("   Group {0}: '{1}'", ctr, match.Groups[ctr].Value);
         int capCtr = 0;
         foreach (Capture capture in match.Groups[ctr].Captures)
         {
            Console.WriteLine("      Capture {0}: '{1}'", capCtr, capture.Value);
            capCtr++;
         }
      }
   }
}
// The example displays the following output:
//       Match: 'This is a short sentence.'
//          Group 1: 'sentence.'
//             Capture 0: 'This '
//             Capture 1: 'is '
//             Capture 2: 'a '
//             Capture 3: 'short '
//             Capture 4: 'sentence.'
//          Group 2: 'sentence'
//             Capture 0: 'This'
//             Capture 1: 'is'
//             Capture 2: 'a'
//             Capture 3: 'short'
//             Capture 4: 'sentence'
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\b(\w+)\W+)+"
      Dim input As String = "This is a short sentence."
      Dim match As Match = Regex.Match(input, pattern)
      Console.WriteLine("Match: '{0}'", match.Value)
      For ctr As Integer = 1 To match.Groups.Count - 1
         Console.WriteLine("   Group {0}: '{1}'", ctr, match.Groups(ctr).Value)
         Dim capCtr As Integer = 0
         For Each capture As Capture In match.Groups(ctr).Captures
            Console.WriteLine("      Capture {0}: '{1}'", capCtr, capture.Value)
            capCtr += 1
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'       Match: 'This is a short sentence.'
'          Group 1: 'sentence.'
'             Capture 0: 'This '
'             Capture 1: 'is '
'             Capture 2: 'a '
'             Capture 3: 'short '
'             Capture 4: 'sentence.'
'          Group 2: 'sentence'
'             Capture 0: 'This'
'             Capture 1: 'is'
'             Capture 2: 'a'
'             Capture 3: 'short'
'             Capture 4: 'sentence'

O padrão da expressão regular (\b(\w+)\W+)+ extrai palavras, uma a uma, da cadeia de caracteres.The regular expression pattern (\b(\w+)\W+)+ extracts individual words from a string. Ele é definido conforme mostrado na tabela a seguir.It is defined as shown in the following table.

PadrãoPattern DescriçãoDescription
\b Começa a correspondência em um limite de palavra.Begin the match at a word boundary.
(\w+) Corresponde a um ou mais caracteres de palavra.Match one or more word characters. Juntos, esses caracteres compõem uma palavra.Together, these characters form a word. Este é o segundo grupo de captura.This is the second 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.
(\b(\w+)\W+) Corresponde ao padrão de um ou mais caracteres de palavra, seguido por um ou mais caracteres que não compõem palavras, uma ou mais vezes.Match the pattern of one or more word characters followed by one or more non-word characters one or more times. Este é o primeiro grupo de captura.This is the first capturing group.

O segundo grupo de captura corresponde a cada palavra da frase.The second capturing group matches each word of the sentence. O primeiro grupo de captura corresponde a cada palavra com a pontuação e o espaço em branco que a segue.The first capturing group matches each word along with the punctuation and white space that follow the word. O objeto Group, cujo índice é 2, fornece informações sobre o texto correspondente ao segundo grupo de captura.The Group object whose index is 2 provides information about the text matched by the second capturing group. O conjunto completo de palavras capturadas pelo grupo de captura está disponível no objeto CaptureCollection, retornado pela propriedade Group.Captures.The complete set of words captured by the capturing group are available from the CaptureCollection object returned by the Group.Captures property.

Consulte tambémSee also