Partilhar via

Agrupando Construtores

  • Artigo

Construções de agrupamento delinear as subexpressões de uma expressão regular e capturar as subseqüências de uma seqüência de caracteres de entrada. Você pode usar construções de agrupamento para fazer o seguinte:

  • Corresponde a uma subexpressão que é repetida na seqüência de entrada.

  • Aplica um quantificador para uma subexpressão que possui vários elementos de linguagem de expressão regular. Para obter mais informações sobre quantificadores, consulte Quantificadores.

  • Incluir uma subexpressão na seqüência de caracteres é retornada pelo Regex.Replace e Match.Result métodos.

  • Recuperar subexpressões individuais da Match.Groups propriedade e processá-los separadamente do texto correspondente como um todo.

A.NET Framework oferece suporte a seguinte expressão regular, construções de agrupamento:

  • Subexpressões correspondentes

  • Chamado subexpressões correspondentes

  • Balanceamento de definições de grupo

  • Grupos de não captura

  • Opções de grupo

  • Declarações de lookahead positivo de largura zero

  • Declarações de lookahead negativo de largura zero

  • Declarações de lookbehind de largura zero positivo

  • Declarações de lookbehind de largura zero negativo

  • Subexpressões nonbacktracking

  • Construções de agrupamento e objetos de expressão regular

Subexpressões correspondentes

A construção de agrupamento a seguir captura uma subexpressão correspondente:

(Subexpressão)

onde subexpressão é qualquer padrão de expressão regular válida. Captura-se de que o uso de parênteses são numeradas automaticamente da esquerda para a direita com base na ordem dos parênteses de abertura na expressão regular, começando em uma. A captura de numeradas de zero é o texto correspondido pelo padrão de toda a expressão regular.

Observação

Se a RegexOptions parâmetro de um método de correspondência de padrão de expressão regular inclui o RegexOptions.ExplicitCapture sinalizador, ou se a n opção é aplicada a este subexpressão (consulte Opções de grupo posteriormente neste tópico), a subexpressão correspondente não for capturada.

Você pode acessar grupos capturados de quatro maneiras:

  • Usando a retrorreferência construa dentro da expressão regular. A subexpressão correspondente é referenciada na mesma expressão regular, usando a sintaxe \número, onde número é o número ordinal da subexpressão capturado.

  • Usando a retrorreferência nomeada construa dentro da expressão regular. A subexpressão correspondente é referenciada na mesma expressão regular, usando a sintaxe \k<número>, onde número é o número ordinal da subexpressão capturado. A subexpressão capturada tem um nome padrão que é idêntico ao seu número ordinal. Para obter mais informações, consulte nome correspondido subexpressões posteriormente neste tópico.

  • Usando o $number seqüência de substituição em um Regex.Replace ou Match.Result chamada de método, onde número é o número ordinal da subexpressão capturado.

  • Programaticamente, usando o GroupCollection objeto retornado pela Match.Groups propriedade. O membro na posição zero na coleção representa a correspondência de toda a expressão regular. Cada membro subseqüente representa uma subexpressão correspondente. Para obter mais informações, consulte o Grouping Constructs and Regular Expression Objects seção.

O exemplo a seguir ilustra uma expressão regular que identifica palavras duplicadas no texto. Dois grupos de captura do padrão de expressão regular representam as duas instâncias da palavra duplicada. A segunda instância é capturada para relatar sua posição inicial na seqüência de entrada.

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.

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.

O padrão de expressão regular é o seguinte:

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

A tabela a seguir mostra como o padrão de expressão regular é interpretado.

Padrão

Descrição

(\w+)

Corresponde a um ou mais caracteres do word. Este é o primeiro grupo de capturando.

\s

Corresponde a um caractere de espaço em branco.

(\1)

Coincide com a seqüência de caracteres no primeiro grupo capturado. Este é o segundo grupo de capturando. O exemplo atribui a um grupo capturado para que a posição inicial da palavra duplicada pode ser recuperada da Match.Index propriedade.

\W

Corresponde a um caractere não word, incluindo o espaço em branco e pontuação. Isso impede que o padrão de expressão regular a correspondência de uma palavra que comece com a palavra do primeiro grupo capturado.

Chamado subexpressões correspondentes

A construção de agrupamento seguinte captura de uma subexpressão correspondente e lhe permite acessá-lo pelo nome ou pelo número:

(?<name>subexpression)

Ou:

(?'name' subexpression)

onde nome é um nome de grupo válido, e subexpressão é qualquer padrão de expressão regular válida. nome não deve conter quaisquer caracteres de pontuação e não pode começar com um número.

Observação

Se a RegexOptions parâmetro de um método de correspondência de padrão de expressão regular inclui o RegexOptions.ExplicitCapture sinalizador, ou se a n opção é aplicada a este subexpressão (consulte Opções de grupo posteriormente neste tópico), a única maneira para capturar uma subexpressão é explicitamente nomear grupos de captura.

Você pode acessar grupos capturados nomeados das seguintes maneiras:

  • Usando a retrorreferência nomeada construa dentro da expressão regular. A subexpressão correspondente é referenciada na expressão regular mesmo usando a sintaxe \k<name>, onde nome é o nome da subexpressão capturado.

  • Usando a retrorreferência construa dentro da expressão regular. A subexpressão correspondente é referenciada na mesma expressão regular, usando a sintaxe \número, onde número é o número ordinal da subexpressão capturado. Nomeado subexpressões correspondentes serão numerados consecutivamente da esquerda para direita após subexpressões correspondentes.

  • Usando o ${nome} seqüência de substituição em um Regex.Replace ou Match.Result chamada de método, onde nome é o nome da subexpressão capturado.

  • Usando o $número> seqüência de substituição em um Regex.Replace ou Match.Result chamada de método, onde número é o número ordinal da subexpressão capturado.

  • Programaticamente, usando o GroupCollection objeto retornado pela Match.Groups propriedade. O membro na posição zero na coleção representa a correspondência de toda a expressão regular. Cada membro subseqüente representa uma subexpressão correspondente. Grupos capturados nomeados são armazenados na coleção após numeradas grupos capturados.

  • Programaticamente, fornecendo o nome subexpressão para o GroupCollection o indexador do objeto (em C#) ou para seu Item propriedade (Visual Basic).

Um padrão de expressão regular simples ilustra como numerada (sem nome) e grupos nomeados podem ser referenciados através de programação ou usando a sintaxe da linguagem de expressão regular. A expressão regular ((?<One>abc)\d+)?(?<Two>xyz)(.*) produz os seguintes grupos de capturando por número e nome. A primeira captura de grupo (número 0) sempre se refere ao padrão de todo.

Número

Nome

Padrão

0

0 (Nome padrão)

((?<One>abc)\d+)?(?<Two>xyz)(.*)

1

1 (Nome padrão)

((?<One>abc)\d+)

2

2 (Nome padrão)

(.*)

3

Um

(?<One>abc)

4

Dois

(?<Two>xyz)

O exemplo a seguir ilustra uma expressão regular que identifica palavras duplicadas e a palavra que segue imediatamente a cada palavra duplicada. O padrão de expressão regular define dois subexpressões nomeados: duplicateWord, que representa a palavra duplicada; e nextWord, que representa a palavra que segue a palavra duplicado.

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

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

O padrão de expressão regular é da seguinte maneira:

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

A tabela a seguir mostra como a expressão regular é interpretada.

Padrão

Descrição

(?<duplicateWord>\w+)

Corresponde a um ou mais caracteres do word. Este grupo de captura duplicateWord.

\s

Corresponde a um caractere de espaço em branco.

\k<duplicateWord>

Coincidir cadeia de caracteres a partir do grupo capturado chamado duplicateWord.

\W

Corresponde a um caractere não word, incluindo o espaço em branco e pontuação. Isso impede que o padrão de expressão regular a correspondência de uma palavra que comece com a palavra do primeiro grupo capturado.

(?<nextWord>\w+)

Corresponde a um ou mais caracteres do word. Este grupo de captura nextWord.

Balanceamento de definições de grupo

Uma definição de grupo balanceamento exclui a definição de um grupo previamente definido e lojas, no grupo atual, o intervalo entre o anteriormente definido e do grupo atual. A construção de agrupamento tem o seguinte formato:

(?<name1-name2>subexpression)

Ou:

(?'name1-name2' subexpression)

onde Nome1 é o grupo atual (opcional), Nome2 é um grupo previamente definido, e subexpressão é qualquer padrão de expressão regular válida. A definição de grupo balanceamento exclui a definição de Nome2 e armazena o intervalo entre Nome2 e Nome1 em Nome1. Se nenhum Nome2 grupo é definido, a correspondência de volta. Como excluir a última definição de Nome2 revela a definição anterior de Nome2, essa construção permite que você usar a pilha de capturas para grupo Nome2 como um contador para manter o controle de construções aninhadas, como, por exemplo, parênteses ou de abertura e fechamento entre colchetes.

A definição de grupo balanceamento usa Nome2 como uma pilha. O caractere inicial de cada construção aninhado é colocado no grupo e em seus Group.Captures coleção. Quando o caractere de fechamento for atendido, o caractere de abertura correspondente é removido do grupo e o Captures coleção é reduzida por um. Depois que o correspondente de abertura e de caracteres de fechamento de construções todos aninhadas, Nome1 está vazio.

Observação

Depois de modificar a expressão regular no exemplo a seguir para usar a abertura apropriada e fechando o caractere de uma construção aninhada, ele pode ser usado para tratar mais aninhadas construções, como, por exemplo, expressões matemáticas ou linhas de código de programa que incluem várias chamadas de método aninhadas.

O exemplo a seguir usa uma definição de grupo balanceamento para corresponder à esquerda e direita ângulo colchetes (<>) em uma seqüência de caracteres de entrada. O exemplo define dois grupos nomeados, Open e Close, que são usados como uma pilha para controlar os pares correspondentes de colchetes angulares. Cada colchete esquerdo capturado é empurrado para a coleção de captura da Open colchete angular direito de grupo e cada capturado é empurrado para a coleção de captura da Close grupo. A definição de grupo balanceamento garante a existência de um colchete angular direito de correspondentes de cada colchete angular esquerdo. Se não, é o subpadrão final, (?(Open)(?!)), é avaliada somente se a Open grupo não está vazio (e, portanto, se tem de todas as construções aninhadas não foi fechado). Se o subpadrão final é avaliado, a correspondência falha, porque a seqüência de caracteres de entrada não deve conter quaisquer ocorrências da subseqüência ?!.

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>

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>

O padrão de expressão regular é:

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

A expressão regular é interpretada da seguinte maneira:

Padrão

Descrição

^

Comece no início da seqüência de caracteres.

[^<>]*

Corresponde a zero ou mais caracteres que não são colchetes à esquerda ou ângulo reto.

(?'Open'<)

Coincidir com um colchete angular esquerdo e atribuí-la a um grupo chamado Open.

[^<>]*

Corresponde a zero ou mais caracteres que não são colchetes à esquerda ou ângulo reto.

((?'Open'<)[^<>]*) +

Corresponde a uma ou mais ocorrências de um colchete angular esquerdo, seguido de zero ou mais caracteres que não são colchetes à esquerda ou ângulo reto. Este é o segundo grupo de capturando.

(?'Close-Open'>)

Coincidir com um colchete angular direito, atribuir a subseqüência de caracteres entre a Open e do grupo atual para o Close de grupo e excluir a definição da Open grupo.

[^<>]*

Corresponde a zero ou mais ocorrências de qualquer caractere que não é à esquerda nem um colchete angular direito.

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

Corresponde a uma ou mais ocorrências de um colchete angular direito, seguido de zero ou mais ocorrências de qualquer caractere que é nem esquerda nem um colchete angular direito. Ao fazer a correspondência de colchete angular direito, atribuir a subseqüência de caracteres entre a Open e do grupo atual para o Close de grupo e excluir a definição da Open grupo. Este é o terceiro grupo de capturando.

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

Corresponde a zero ou mais ocorrências do seguinte padrão: uma ou mais ocorrências de um colchete angular esquerdo, seguido de zero ou mais caracteres de colchete de ângulo, seguidos por uma ou mais ocorrências de um colchete angular direito, seguido de zero ou mais ocorrências de não-colchetes. Ao fazer a correspondência de colchete angular direito, excluir a definição da Open de grupo e atribuir a subseqüência de caracteres entre a Open e do grupo atual para o Close grupo. Este é o primeiro grupo de capturando.

(?(Open)(?!))

Se o Open grupo existe, corresponde a um ponto de interrogação e um ponto de exclamação. Se a Open grupo é definido, a correspondência falha, o que indica que os colchetes não são balanceados.

$

Corresponde ao final da seqüência de entrada.

A subexpressão final, (?(Open)(?!)), indica se o aninhamento construções em a seqüência de caracteres de entrada são corretamente balanceados (por exemplo, se cada colchete angular esquerdo é correspondido por um colchete angular direito). Ele usa a correspondência condicional com base em um grupo capturado válido; Para obter mais informações, consulte Construtores de Alternância. Se o Open grupo é definido, o mecanismo de expressão regular tenta corresponder a subexpressão (?!) na seqüência de caracteres de entrada. O Open grupo deve ser definido somente se o aninhamento de construções são desbalanceadas. Portanto, o padrão a ser correspondido a seqüência de caracteres de entrada deve ser aquele que não pode ocorrer na seqüência de entrada, que faz a correspondência de falhar.

No exemplo, o mecanismo de expressão regular avalia a seqüência de caracteres de entrada "< mno <xyz> > <abc>" conforme mostrado na tabela a seguir.

Por Etapa

Padrão

Resultado

1

^

Inicia a correspondência no início da seqüência de entrada

2

[^<>]*

Procura por caracteres de colchete de ângulo antes do colchete angular esquerdo; não encontrar nenhuma correspondência.

3

(((?'Open'<)

Coincide com o colchete angular esquerdo em "<abc>" e atribui-lo para o Open grupo.

4

[^<>]*

Corresponde a "abc".

5

)+

"< abc" é o valor do segundo grupo capturado.

O próximo caractere na seqüência de entrada não é um colchete angular esquerdo, para que o mecanismo de expressão regular de loop não volta para o (?'Open'<)[^<>]*) subpadrão.

6

((?'Close-Open')

O parênteses de ângulo reto em "<abc>", "abc", que é a subseqüência de atribui entre a Open de grupo e o ângulo reto colchetes, como o Close Agrupar e exclui o valor atual ("<") da Open group, deixando-o vazio.

7

[^<>]*

Procura por caracteres de colchete de ângulo após o colchete angular direito; não encontrar nenhuma correspondência.

8

)+

O valor do terceiro grupo capturado é "[]".

O próximo caractere na seqüência de entrada não é um colchete angular direito, para que o mecanismo de expressão regular de loop não volta para o ((?'Close-Open'>)[^<>]*) subpadrão.

9

)*

O valor do primeiro grupo capturado é "<abc>".

O próximo caractere na seqüência de entrada é um colchete angular esquerdo, para que o mecanismo de expressão regular faz um loop volta para o (((?'Open'<) subpadrão.

10

(((?'Open'<)

Coincide com o colchete angular esquerdo em "<mno>" e atribui-lo para o Open grupo. Sua Group.Captures coleção agora tem um valor único, "<".

11

[^<>]*

Correspondências "mno".

12

)+

"< mno" é o valor do segundo grupo capturado.

O próximo caractere na seqüência de entrada é um colchete angular esquerdo, para que o mecanismo de expressão regular faz um loop volta para o (?'Open'<)[^<>]*) subpadrão.

13

(((?'Open'<)

Coincide com o colchete angular esquerdo em "<xyz>" e atribui-lo para o Open grupo. O Group.Captures coleção da Open grupo agora inclui duas capturas: o colchete angular esquerdo de "<mno>" e o colchete angular esquerdo de "<xyz>".

14

[^<>]*

Correspondências "xyz".

15

)+

"< xyz" é o valor do segundo grupo capturado.

O próximo caractere na seqüência de entrada não é um colchete angular esquerdo, para que o mecanismo de expressão regular de loop não volta para o (?'Open'<)[^<>]*) subpadrão.

16

((?'Close-Open')

Coincide com o colchete angular direito em "<xyz>". " XYZ", atribui a subseqüência de caracteres entre a Open colchete de grupo e o ângulo da direita para a Close de grupo e, em seguida, exclui o valor atual da Open grupo. O valor da captura anterior (o colchete angular esquerdo em "<mno>") se torna o valor atual de Open grupo. O Captures coleção da Open grupo agora inclui uma captura única, o colchete angular esquerdo de "<xyz>".

17

[^<>]*

Procura por caracteres de colchete de ângulo; não encontrar nenhuma correspondência.

18

)+

O valor do terceiro grupo capturado é "[]".

O próximo caractere na seqüência de entrada é um colchete angular direito, para que o mecanismo de expressão regular faz um loop volta para o ((?'Close-Open'>)[^<>]*) subpadrão.

19

((?'Close-Open')

Coincide com o colchete angular final de direito em "xyz >>", atribui "mno <xyz>" (subseqüência de caracteres entre a Open grupo e o colchete angular direito) para o Close de grupo e, em seguida, exclui o valor atual da Open grupo. O Open grupo é agora vazio.

20

[^<>]*

Procura por caracteres de colchete de ângulo; não encontrar nenhuma correspondência.

21

)+

O valor do terceiro grupo capturado é "[]".

O próximo caractere na seqüência de entrada não é um colchete angular direito, para que o mecanismo de expressão regular de loop não volta para o ((?'Close-Open'>)[^<>]*) subpadrão.

22

)*

O valor do primeiro grupo capturado é "< mno <xyz> >".

O próximo caractere na seqüência de entrada não é um colchete angular esquerdo, para que o mecanismo de expressão regular de loop não volta para o (((?'Open'<) subpadrão.

23

(?(Open)(?!))

O Open grupo não está definido para que nenhuma correspondência é tentada.

24

$

Corresponde ao final da seqüência de entrada.

Grupos de não captura

A seguinte construção de agrupamento não captura a subseqüência de caracteres que corresponde a uma subexpressão:

(?:subexpression)

onde subexpressão é qualquer padrão de expressão regular válida. A construção do grupo de não captura é normalmente usada quando um quantificador é aplicado a um grupo, mas as subseqüências capturadas pelo grupo são de nenhum interesse.

Observação

Se uma expressão regular inclui construções de agrupamento aninhado, a construção de uma grupo de não captura externo não se aplica para as construções de grupo aninhado interno.

O exemplo a seguir ilustra uma expressão regular que inclui grupos de não captura. Observe que a saída não inclui quaisquer grupos capturados.

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.

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.

A expressão regular (?:\b(?:\w+)\W*)+\. corresponde a uma frase que está terminada por um período. Porque a expressão regular se concentra em sentenças e não em palavras individuais, o agrupamento construções são usadas exclusivamente como quantificadores. O padrão de expressão regular é interpretado como mostrado na tabela a seguir.

Padrão

Descrição

\b

Começa a correspondência de um limite de palavra.

(?:\w+)

Corresponde a um ou mais caracteres do word. Não atribua o texto correspondente a um grupo capturado.

\W*

Corresponde a zero ou mais caracteres não-word.

(?:\b(?:\w+)\W*)+

Coincide com o padrão de um ou mais caracteres do word, começando em um limite de palavra, seguido de zero ou mais caracteres não word, uma ou mais vezes. Não atribua o texto correspondente a um grupo capturado.

\.

Corresponde a um período.

Opções de grupo

A construção de agrupamento a seguir aplica-se ou desativa as opções especificadas dentro de uma subexpressão:

(?imnsx-imnsx:Subexpressão)

onde subexpressão é qualquer padrão de expressão regular válida. Por exemplo, (?i-s:) ativa a não distinção entre maiúsculas e minúsculas e desativa o modo linha-única. Para obter mais informações sobre as opções de linha, você pode especificar, consulte Opções de expressão Regular.

Observação

Você pode especificar as opções que se aplicam a uma expressão regular inteira em vez de uma subexpressão usando um System.Text.RegularExpressions.Regex o construtor de classe ou um método estático.Você também pode especificar opções de in-line aplicam após um ponto específico em uma expressão regular, usando o (?imnsx-imnsx) construção de linguagem.

A construção de opções de grupo não é um grupo de captura. Isto é, embora qualquer parte de uma seqüência de caracteres que é capturada por subexpressão é incluído na correspondência, ele não está incluído em um grupo capturado nem usado para preencher o GroupCollection objeto.

Por exemplo, a expressão regular \b(?ix: d \w+)\s no exemplo a seguir usa as opções de linha em uma construção de agrupamento para ativar a correspondência de maiúsculas e minúsculas e ignorar o espaço em branco de padrão na identificação de todas as palavras que começam com a letra "d". A expressão regular é definida como mostrado na tabela a seguir.

Padrão

Descrição

\b

Começa a correspondência de um limite de palavra.

(?ix: d \w+)

Usando a correspondência e ignorando o espaço em branco neste padrão de maiúsculas e minúsculas, corresponde ao "d" seguido por um ou mais caracteres do word.

\s

Corresponde a um caractere de espaço em branco.

 
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.      

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.

Declarações Lookahead positivo de largura zero

A construção de agrupamento a seguir define uma afirmação lookahead positivo de largura zero:

(?=Subexpressão)

onde subexpressão é qualquer padrão de expressão regular. Uma correspondência seja bem-sucedido, a seqüência de caracteres de entrada deve coincidir com o padrão de expressão regular no subexpressão, embora a substring correspondida não está incluída no resultado da correspondência. Uma declaração lookahead positivo de largura zero não rastreamento inverso.

Normalmente, uma afirmação lookahead positivo de largura zero encontra-se no final de um padrão de expressão regular. Ele define uma subseqüência de caracteres que deve ser encontrado no final de uma seqüência de caracteres para que haja correspondência, mas que não devem ser incluídos na coincidência. Também é útil para evitar o excesso de backtracking. Você pode usar uma afirmação lookahead positivo de largura zero para garantir que um determinado grupo capturado começa com o texto que corresponda a um subconjunto do padrão definido para esse grupo capturado. Por exemplo, se um grupo de captura corresponder os caracteres consecutivos do word, você pode usar uma afirmação lookahead positivo de largura zero para exigir que o primeiro caractere seja um caractere alfabético de maiúsculas.

O seguinte exemplo usa uma afirmação lookahead positivo de largura zero para coincidir com a palavra que precede o verbo "é" a seqüência de caracteres de entrada.

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

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

A expressão regular \b\w+(?=\sis\b) é interpretado como mostrado na tabela a seguir.

Padrão

Descrição

\b

Começa a correspondência de um limite de palavra.

\w+

Corresponde a um ou mais caracteres do word.

(?=\sis\b)

Determine se os caracteres do word são seguidos por um caractere de espaço em branco e a seqüência de caracteres "é", que termina em um limite de palavra. Nesse caso, a correspondência for bem-sucedida.

Declarações Lookahead negativo de largura zero

A construção de agrupamento a seguir define uma afirmação lookahead negativo de largura zero:

(?!Subexpressão)

onde subexpressão é qualquer padrão de expressão regular. Para o correspondente seja bem-sucedido, a seqüência de caracteres de entrada não deve corresponder ao padrão da expressão regular no subexpressão, apesar da seqüência de caracteres correspondente não está incluída no resultado da correspondência.

Uma declaração lookahead negativo de largura zero é normalmente usada no início ou no final de uma expressão regular. No início de uma expressão regular, ele pode definir um padrão específico que não deve ter correspondência ao início da expressão regular define um padrão semelhante, mas mais geral, a ser correspondido. Nesse caso, é freqüentemente usado para limitar o backtracking. No final de uma expressão regular, ele pode definir uma subexpressão que não pode ocorrer no final de uma correspondência.

O exemplo a seguir define uma expressão regular que usa uma declaração de visão antecipada de largura zero no início da expressão regular para corresponder às palavras que não começam com "un".

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

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

A expressão regular \b(?!un)\w+\b é interpretado como mostrado na tabela a seguir.

Padrão

Descrição

\b

Começa a correspondência de um limite de palavra.

(?!un)

Determine se os caracteres de dois próximos são "un". Se não, uma correspondência é possível.

\w+

Corresponde a um ou mais caracteres do word.

\b

Finalize a correspondência de um limite de palavra.

O exemplo a seguir define uma expressão regular que usa uma declaração de visão antecipada de largura zero no final da expressão regular para corresponder às palavras que não terminam com um caractere de pontuação.

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

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

A expressão regular \b\w+\b(?!\p{P}) é interpretado como mostrado na tabela a seguir.

Padrão

Descrição

\b

Começa a correspondência de um limite de palavra.

\w+

Corresponde a um ou mais caracteres do word.

\b

Finalize a correspondência de um limite de palavra.

\p{P})

Se o próximo caractere não é um símbolo de pontuação (como, por exemplo, um ponto ou uma vírgula), a correspondência é bem-sucedida.

Declarações de Lookbehind positiva de largura zero

A construção de agrupamento a seguir define uma declaração de lookbehind de largura zero positivo:

(?<=Subexpressão)

onde subexpressão é qualquer padrão de expressão regular. Uma correspondência seja bem-sucedido, subexpressão deve ocorrer na seqüência de entrada à esquerda da posição atual, embora subexpression não está incluído no resultado de correspondência. Uma declaração de lookbehind de largura zero positivo não rastreamento inverso.

Declarações de lookbehind de largura zero positivos são normalmente usadas no início de expressões regulares. O padrão que eles definem é uma pré-condição para uma correspondência, embora não seja uma parte do resultado corresponder.

Por exemplo, o exemplo a seguir corresponde os dois últimos dígitos do ano do século vinte primeiro (isto é, ele requer que os dígitos "20" preceda a seqüência de caracteres correspondente).

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

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

O padrão de expressão regular (?<=\b20)\d{2}\b é interpretado como mostrado na tabela a seguir.

Padrão

Descrição

\d{2}

Coincide com dois dígitos decimais.

{?<=\b20)

Continuar a correspondência se os dois dígitos decimais são precedidos pelos dígitos decimais "20" em um limite de palavra.

\b

Finalize a correspondência de um limite de palavra.

Declarações de lookbehind de largura zero positivo também são usadas para limitar o backtracking quando o último caractere ou caracteres em um grupo capturado devem ser um subconjunto dos caracteres que corresponde ao padrão de expressão regular do grupo. Por exemplo, se um grupo de captura todos os caracteres alfabéticos consecutivos, você pode usar uma declaração de lookbehind de largura zero positivo para exigir que o último caractere seja em ordem alfabética.

Largura zero negativo declarações de Lookbehind

A construção de agrupamento a seguir define uma declaração de lookbehind de largura zero negativo:

(?<!Subexpressão)

onde subexpressão é qualquer padrão de expressão regular. Uma correspondência seja bem-sucedido, subexpressão não deve ocorrer na seqüência de entrada à esquerda da posição atual. No entanto, que não corresponde a qualquer substring subexpression não está incluído no resultado de correspondência.

Lookbehind de largura zero negativo afirmações são normalmente usadas no início de expressões regulares. O padrão que eles definem impede uma correspondência na seqüência de caracteres que se segue. Eles também são usados para limitar o backtracking quando o último caractere ou caracteres em um grupo capturado não devem ser um ou mais dos caracteres que corresponde ao padrão de expressão regular do grupo. Por exemplo, se um grupo de captura todos os caracteres alfabéticos consecutivos, você pode usar uma declaração de lookbehind de largura zero positivo para exigir que o último caractere não seja um sublinhado (_).

O exemplo a seguir corresponde a data para qualquer dia da semana em que não é um final de semana (isto é, que é sábado nem domingo).

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

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

O padrão de expressão regular (?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b é interpretado como mostrado na tabela a seguir.

Padrão

Descrição

\b

Começa a correspondência de um limite de palavra.

\w+

Corresponde a um ou mais caracteres do word, seguidos por um caractere de espaço em branco.

\d{1,2},

Corresponde a um ou dois dígitos decimais, seguidos por um caractere de espaço em branco e uma vírgula.

\d{4}\b

Corresponde a quatro dígitos decimais e finalizar a correspondência de um limite de palavra.

(?<!(Saturday|Sunday) )

Se a correspondência é precedida por algo diferente, por exemplo, as seqüências de caracteres, "Sábado" ou "Domingo" seguido por um espaço, a correspondência for bem-sucedida.

Subexpressões nonbacktracking

A construção de agrupamento a seguir representa uma subexpressão nonbacktracking (também conhecido como um "cavalo" subexpressão):

(?>Subexpressão)

onde subexpressão é qualquer padrão de expressão regular.

Normalmente, se uma expressão regular inclui um recurso opcional ou a alternativa de correspondência de padrão e uma correspondência não tiver êxito, o mecanismo de expressões regulares pode ramificar em várias direções para coincidir com uma seqüência de caracteres de entrada com um padrão. Se não for encontrada uma correspondência quando se leva a primeira ramificação, o mecanismo de expressão regular pode fazer backup ou refazer o caminho até o ponto em que levava a primeira correspondência e tente a correspondência com a segunda ramificação. Esse processo pode continuar até que tentou todas as ramificações.

O (?>subexpressão) desabilita backtracking de construção de linguagem. O mecanismo de expressão regular corresponderá quantos caracteres na seqüência de entrada possível. Quando nenhuma correspondência for possível, ele não será rastreamento inverso para tentar a alternativa de padrões correspondentes. (Isto é, a subexpressão corresponde somente cadeias de caracteres que deve ser correspondidas pela subexpressão sozinha; ele não tenta corresponder uma cadeia baseada a subexpressão e qualquer subexpressões que o seguem.)

Essa opção é recomendada se você souber que não terá êxito backtracking. Impedindo que o mecanismo de expressão regular realizando a pesquisa desnecessárias melhora o desempenho.

O exemplo a seguir ilustra como uma subexpressão nonbacktracking modifica os resultados de uma correspondência de padrão. Backtracking expressão regular corresponde a uma série de caracteres repetidos, seguido de mais de uma ocorrência do mesmo caractere em um limite de palavra com êxito, mas não a expressão regular nonbacktracking.

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

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

A expressão regular nonbacktracking (?>(\w)\1+).\b é definido como mostrado na tabela a seguir.

Padrão

Descrição

(\w)

Corresponde a um caractere de palavra única e atribuí-lo ao primeiro grupo de captura.

\1+

Corresponde ao valor da subseqüência capturada primeiro uma ou mais vezes.

.

Corresponde a qualquer caractere.

\b

Finalize a correspondência de um limite de palavra.

(?[](\w)\1+)

Corresponde a uma ou mais ocorrências de um caractere de palavra duplicados, mas não rastreamento inverso para coincidir com o último caractere em um limite de palavra.

Construções de agrupamento e objetos de expressão Regular

Substrings que correspondem por uma expressão regular captura de grupo são representados por System.Text.RegularExpressions.Group objetos, que podem ser recuperados a partir do System.Text.RegularExpressions.GroupCollection objeto retornado pelo Match.Groups propriedade. O GroupCollection objeto está preenchido da seguinte maneira:

  • O primeiro Group o objeto da coleção (o objeto no índice zero) representa toda correspondência.

  • O próximo conjunto de Group os objetos representam sem nome (numerada) captura grupos. Eles aparecem na ordem em que são definidos na expressão regular, da esquerda para a direita. Os valores de índice do intervalo grupos de 1 o número de sem nome capturando grupos na coleção. (O índice de um determinado grupo é equivalente à sua retrorreferência numerada. Para obter mais informações sobre referências anteriores, consulte Construtores de Referência Passada.)

  • O conjunto final de Group os objetos representam grupos de captura nomeado. Eles aparecem na ordem em que são definidos na expressão regular, da esquerda para a direita. O valor de índice do primeiro denominado grupo de captura é um maior do que o índice do último grupo de capturando sem nome. Se houver não sem nome grupos na expressão regular de captura, o valor de índice do primeiro denominado grupo de captura é zero.

Se você aplicar um quantificador para um grupo de captura, o correspondente Group do objeto Capture.Value, Capture.Index, e Capture.Length Propriedades refletem a última subseqüência de caracteres que é capturada por um grupo de captura. Você pode recuperar um conjunto completo de substrings que são capturados pelos grupos que têm quantificadores a partir do CaptureCollection objeto retornado pelo Group.Captures propriedade.

O exemplo a seguir esclarece a relação entre a Group e Capture objetos.

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

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

O padrão de expressão regular \b(\w+)\W+)+ extrai palavras individuais de uma seqüência de caracteres. Ele é definido como mostrado na tabela a seguir.

Padrão

Descrição

\b

Começa a correspondência de um limite de palavra.

(\w+)

Corresponde a um ou mais caracteres do word. Juntos, esses caracteres formam uma palavra. Este é o segundo grupo de capturando.

\W+

Corresponde a um ou mais caracteres não-word.

(\w+)\W+)+

Correspondência do padrão de um ou mais caracteres do word, seguido de uma ou mais não word caracteres de uma ou mais vezes. Este é o primeiro grupo de capturando.

O primeiro grupo de capturando corresponde a cada palavra da frase. O segundo grupo de capturando corresponde a cada palavra juntamente com a pontuação e espaços em branco que seguem a palavra. O Group objeto cujo índice é 2 fornece informações sobre o texto correspondido pela segunda captura grupo. O conjunto completo de palavras capturado pelo grupo de captura estão disponíveis a partir de CaptureCollection objeto retornado pela Group.Captures propriedade.

Consulte também

Conceitos

Elementos de linguagem das expressões regulares

Retrocedendo