Match.NextMatch Método
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Devuelve un nuevo objeto Match con los resultados de la siguiente coincidencia, empezando en la posición donde finalizó la última (en el carácter siguiente al último que coincidía).
public:
System::Text::RegularExpressions::Match ^ NextMatch();public System.Text.RegularExpressions.Match NextMatch ();member this.NextMatch : unit -> System.Text.RegularExpressions.MatchPublic Function NextMatch () As MatchDevoluciones
Siguiente coincidencia de expresión regular.
Excepciones
Se agotó el tiempo de espera.
Ejemplos
En el ejemplo siguiente se usa el NextMatch método para capturar coincidencias de expresiones regulares más allá de la primera coincidencia.
#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
Comentarios
Este método es similar a llamar Regex.Match(String, Int32) de nuevo y pasar (Index+Length) como la nueva posición inicial.
Nota
Este método no modifica la instancia actual. En su lugar, devuelve un nuevo Match objeto que contiene información sobre la siguiente coincidencia.
Si se intenta recuperar la siguiente coincidencia, se puede producir un RegexMatchTimeoutException valor de tiempo de espera para las operaciones coincidentes y el intento de encontrar la siguiente coincidencia supera ese intervalo de tiempo de espera.
Notas a los autores de las llamadas
Cuando se repite un intento de coincidencia llamando al NextMatch() método , el motor de expresiones regulares proporciona coincidencias vacías con un tratamiento especial. Normalmente, NextMatch() comienza la búsqueda de la siguiente coincidencia exactamente donde se dejó la coincidencia anterior. Sin embargo, después de una coincidencia vacía, el NextMatch() método avanza por un carácter antes de intentar la siguiente coincidencia. Este comportamiento garantiza que el motor de expresiones regulares avanzará a través de la cadena. De lo contrario, dado que una coincidencia vacía no da lugar a ningún movimiento hacia delante, la siguiente coincidencia empezaría exactamente en el mismo lugar que la coincidencia anterior y coincidiría repetidamente con la misma cadena vacía.
Esto se muestra en el ejemplo siguiente. El patrón de expresión regular a* busca cero o más apariciones de la letra "a" en la cadena "abaabb". Como se muestra en la salida del ejemplo, la búsqueda busca seis coincidencias. El primer intento de coincidencia busca el primer "a". La segunda coincidencia comienza exactamente donde finaliza la primera coincidencia, antes del primer b; busca cero repeticiones de "a" y devuelve una cadena vacía. La tercera coincidencia no comienza exactamente donde finalizó la segunda coincidencia, porque la segunda coincidencia devolvió una cadena vacía. En su lugar, comienza un carácter más adelante, después del primer "b". La tercera coincidencia busca dos apariciones de "a" y devuelve "aa". El cuarto intento de coincidencia comienza donde finalizó la tercera coincidencia, antes del segundo "b" y devuelve una cadena vacía. El quinto intento de coincidencia vuelve a avanzar un carácter para que comience antes del tercer "b" y devuelva una cadena vacía. La sexta coincidencia comienza después de la última "b" y devuelve una cadena vacía de nuevo.
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.