Match.NextMatch Método
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Retorna um novo objeto Match com os resultados para a próxima correspondência, começando na posição em que a última correspondência terminou (no caractere após o último caractere correspondente).
public:
System::Text::RegularExpressions::Match ^ NextMatch();public System.Text.RegularExpressions.Match NextMatch ();member this.NextMatch : unit -> System.Text.RegularExpressions.MatchPublic Function NextMatch () As MatchRetornos
A próxima expressão regular de correspondência.
Exceções
Ocorreu um tempo limite.
Exemplos
O exemplo a seguir usa o NextMatch método para capturar correspondências de expressão regulares além da primeira correspondência.
#using <System.dll>
using namespace System;
using namespace System::Text::RegularExpressions;
void main()
{
String^ text = "One car red car blue car";
String^ pat = "(\\w+)\\s+(car)";
// Compile the regular expression.
Regex^ r = gcnew Regex( pat,RegexOptions::IgnoreCase );
// Match the regular expression pattern against a text string.
Match^ m = r->Match(text);
int matchCount = 0;
while ( m->Success )
{
Console::WriteLine( "Match{0}", ++matchCount );
for ( int i = 1; i <= 2; i++ )
{
Group^ g = m->Groups[ i ];
Console::WriteLine( "Group{0}='{1}'", i, g );
CaptureCollection^ cc = g->Captures;
for ( int j = 0; j < cc->Count; j++ )
{
Capture^ c = cc[ j ];
System::Console::WriteLine( "Capture{0}='{1}', Position={2}", j, c, c->Index );
}
}
m = m->NextMatch();
}
}
// This example displays the following output:
// Match1
// Group1='One'
// Capture0='One', Position=0
// Group2='car'
// Capture0='car', Position=4
// Match2
// Group1='red'
// Capture0='red', Position=8
// Group2='car'
// Capture0='car', Position=12
// Match3
// Group1='blue'
// Capture0='blue', Position=16
// Group2='car'
// Capture0='car', Position=21
using System;
using System.Text.RegularExpressions;
class Example
{
static void Main()
{
string text = "One car red car blue car";
string pat = @"(\w+)\s+(car)";
// Instantiate the regular expression object.
Regex r = new Regex(pat, RegexOptions.IgnoreCase);
// Match the regular expression pattern against a text string.
Match m = r.Match(text);
int matchCount = 0;
while (m.Success)
{
Console.WriteLine("Match"+ (++matchCount));
for (int i = 1; i <= 2; i++)
{
Group g = m.Groups[i];
Console.WriteLine("Group"+i+"='" + g + "'");
CaptureCollection cc = g.Captures;
for (int j = 0; j < cc.Count; j++)
{
Capture c = cc[j];
System.Console.WriteLine("Capture"+j+"='" + c + "', Position="+c.Index);
}
}
m = m.NextMatch();
}
}
}
// This example displays the following output:
// Match1
// Group1='One'
// Capture0='One', Position=0
// Group2='car'
// Capture0='car', Position=4
// Match2
// Group1='red'
// Capture0='red', Position=8
// Group2='car'
// Capture0='car', Position=12
// Match3
// Group1='blue'
// Capture0='blue', Position=16
// Group2='car'
// Capture0='car', Position=21
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim text As String = "One car red car blue car"
Dim pattern As String = "(\w+)\s+(car)"
' Instantiate the regular expression object.
Dim r As Regex = new Regex(pattern, RegexOptions.IgnoreCase)
' Match the regular expression pattern against a text string.
Dim m As Match = r.Match(text)
Dim matchcount as Integer = 0
Do While m.Success
matchCount += 1
Console.WriteLine("Match" & (matchCount))
Dim i As Integer
For i = 1 to 2
Dim g as Group = m.Groups(i)
Console.WriteLine("Group" & i & "='" & g.ToString() & "'")
Dim cc As CaptureCollection = g.Captures
Dim j As Integer
For j = 0 to cc.Count - 1
Dim c As Capture = cc(j)
Console.WriteLine("Capture" & j & "='" & c.ToString() _
& "', Position=" & c.Index)
Next
Next
m = m.NextMatch()
Loop
End Sub
End Module
' This example displays the following output:
' Match1
' Group1='One'
' Capture0='One', Position=0
' Group2='car'
' Capture0='car', Position=4
' Match2
' Group1='red'
' Capture0='red', Position=8
' Group2='car'
' Capture0='car', Position=12
' Match3
' Group1='blue'
' Capture0='blue', Position=16
' Group2='car'
' Capture0='car', Position=21
Comentários
Esse método é semelhante a chamar Regex.Match(String, Int32) novamente e passar (Index+Length) como a nova posição inicial.
Observação
Esse método não modifica a instância atual. Em vez disso, ele retorna um novo Match objeto que contém informações sobre a próxima correspondência.
Tentar recuperar a próxima correspondência pode gerar um RegexMatchTimeoutException valor de tempo limite para operações correspondentes e a tentativa de localizar a próxima correspondência excede esse intervalo de tempo limite.
Notas aos Chamadores
Quando uma tentativa de correspondência é repetida chamando o NextMatch() método, o mecanismo de expressão regular fornece tratamento especial de correspondências vazias. Normalmente, NextMatch() inicia a pesquisa para a próxima correspondência exatamente onde a correspondência anterior parou. No entanto, após uma correspondência vazia, o NextMatch() método avança por um caractere antes de tentar a próxima correspondência. Esse comportamento garante que o mecanismo de expressão regular progrida pela cadeia de caracteres. Caso contrário, como uma correspondência vazia não resulta em nenhum movimento para a frente, a próxima partida começaria exatamente no mesmo lugar que a partida anterior, e corresponderia à mesma cadeia de caracteres vazia repetidamente.
O exemplo a seguir ilustra esse cenário. O padrão de expressão regular a* procura zero ou mais ocorrências da letra "a" na cadeia de caracteres "abaabb". Como mostra a saída do exemplo, a pesquisa localiza seis correspondências. A primeira tentativa de correspondência encontra o primeiro "a". A segunda partida começa exatamente onde a primeira partida termina, antes do primeiro b; ele não encontra nenhuma ocorrência de "a" e retorna uma cadeia de caracteres vazia. A terceira partida não começa exatamente onde a segunda partida terminou, porque a segunda partida retornou uma cadeia de caracteres vazia. Em vez disso, ele começa um caractere mais tarde, após o primeiro "b". A terceira correspondência encontra duas ocorrências de "a" e retorna "aa". A quarta tentativa de jogo começa onde a terceira partida terminou, antes do segundo "b", e retorna uma cadeia de caracteres vazia. A quinta tentativa de correspondência avança novamente um caractere para que ele comece antes do terceiro "b" e retorne uma cadeia de caracteres vazia. A sexta partida começa após o último "b" e retorna uma cadeia de caracteres vazia novamente.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = "a*";
string input = "abaabb";
Match m = Regex.Match(input, pattern);
while (m.Success) {
Console.WriteLine("'{0}' found at index {1}.",
m.Value, m.Index);
m = m.NextMatch();
}
}
}
// The example displays the following output:
// 'a' found at index 0.
// '' found at index 1.
// 'aa' found at index 2.
// '' found at index 4.
// '' found at index 5.
// '' found at index 6.