Condividi tramite


Match.NextMatch Metodo

Definizione

Restituisce un nuovo oggetto Match con i risultati relativi alla corrispondenza successiva, partendo dalla posizione in cui terminava l'ultima corrispondenza (dal carattere dopo l'ultimo carattere corrispondente).

public:
 System::Text::RegularExpressions::Match ^ NextMatch();
public System.Text.RegularExpressions.Match NextMatch ();
member this.NextMatch : unit -> System.Text.RegularExpressions.Match
Public Function NextMatch () As Match

Restituisce

Corrispondenza dell'espressione regolare successiva.

Eccezioni

Si è verificato un timeout.

Esempio

Nell'esempio seguente viene usato il NextMatch metodo per acquisire corrispondenze regolari oltre la prima corrispondenza.

#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

Commenti

Questo metodo è simile alla chiamata Regex.Match(String, Int32) di nuovo e al passaggio (Index+Length) come nuova posizione iniziale.

Nota

Questo metodo non modifica l'istanza corrente. Restituisce invece un nuovo Match oggetto che contiene informazioni sulla corrispondenza successiva.

Il tentativo di recuperare la corrispondenza successiva può generare un'eccezione RegexMatchTimeoutException se è attivo un valore di timeout per le operazioni di corrispondenza e il tentativo di trovare la corrispondenza successiva supera tale intervallo di timeout.

Note per i chiamanti

Quando un tentativo di corrispondenza viene ripetuto chiamando il NextMatch() metodo , il motore delle espressioni regolari fornisce corrispondenze vuote per un trattamento speciale. In genere, NextMatch() inizia la ricerca della corrispondenza successiva esattamente dove è stata interrotta la corrispondenza precedente. Tuttavia, dopo una corrispondenza vuota, il NextMatch() metodo avanza di un carattere prima di provare la corrispondenza successiva. Questo comportamento garantisce che il motore delle espressioni regolari passi attraverso la stringa. In caso contrario, poiché una corrispondenza vuota non comporta alcun movimento in avanti, la corrispondenza successiva inizierebbe esattamente nella stessa posizione della corrispondenza precedente e corrisponderebbe ripetutamente alla stessa stringa vuota.

Nell'esempio seguente viene illustrato questo concetto. Il criterio a* di espressione regolare cerca zero o più occorrenze della lettera "a" nella stringa "abaabb". Come illustrato nell'output dell'esempio, la ricerca trova sei corrispondenze. Il primo tentativo di corrispondenza trova il primo "a". La seconda corrispondenza inizia esattamente dove termina la prima corrispondenza, prima del primo b; trova zero occorrenze di "a" e restituisce una stringa vuota. La terza corrispondenza non inizia esattamente dove è terminata la seconda corrispondenza, perché la seconda corrispondenza ha restituito una stringa vuota. Inizia invece un carattere in un secondo momento, dopo il primo "b". La terza corrispondenza trova due occorrenze di "a" e restituisce "aa". Il quarto tentativo di corrispondenza inizia dove è terminata la terza corrispondenza, prima del secondo "b" e restituisce una stringa vuota. Il quinto tentativo di corrispondenza avanza di nuovo un carattere in modo che inizi prima del terzo "b" e restituisca una stringa vuota. La sesta corrispondenza inizia dopo l'ultima "b" e restituisce di nuovo una stringa vuota.

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.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "a*"
      Dim input As String = "abaabb"
      
      Dim m As Match = Regex.Match(input, pattern)
      Do While m.Success
         Console.WriteLine("'{0}' found at index {1}.", 
                           m.Value, m.Index)
         m = m.NextMatch()
      Loop         
   End Sub
End Module
' 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.

Si applica a