Match.NextMatch Metoda

Reference

Definice

Obor názvů:: System.Text.RegularExpressions

Sestavení:: System.Text.RegularExpressions.dll

Sestavení:: System.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Vrátí nový Match objekt s výsledky pro další shodu počínaje pozicí, na které poslední shoda skončila (na znaku za posledním odpovídajícím znakem).

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

Návraty

Match

Další regulární výraz se shoduje.

Výjimky

RegexMatchTimeoutException

Došlo k vypršení časového limitu.

Příklady

Následující příklad používá metodu NextMatch k zachycení shody regulárního výrazu nad rámec první shody.

#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

Poznámky

Tato metoda se podobá opětovnému volání Regex.Match(String, Int32) a předání (Index+Length) jako nové počáteční pozice.

Poznámka

Tato metoda neupravuje aktuální instanci. Místo toho vrátí nový Match objekt, který obsahuje informace o další shodě.

Pokus o načtení další shody může vyvolat RegexMatchTimeoutException hodnotu časového limitu pro odpovídající operace a pokus o nalezení další shody překročí tento časový limit.

Poznámky pro volající

Když se pokus o shodu opakuje voláním NextMatch() metody, modul regulárních výrazů dává prázdné shody zvláštní zacházení. Obvykle začíná hledání další shody přesně tam, NextMatch() kde předchozí shoda skončila. Po prázdné shodě NextMatch() však metoda před pokusem o další shodu přejde o jeden znak. Toto chování zaručuje, že modul regulárních výrazů bude procházet řetězcem. V opačném případě, protože prázdná shoda nemá za následek žádný pohyb vpřed, další shoda by začala přesně na stejném místě jako předchozí shoda a odpovídala by stejnému prázdnému řetězci opakovaně.

V následujícím příkladu je uvedena ukázka. Vzor regulárního výrazu a* vyhledá nula nebo více výskytů písmena "a" v řetězci "abaabb". Jak ukazuje výstup z příkladu, hledání najde šest shod. První pokus o shodu najde první "a". Druhá shoda začíná přesně tam, kde končí první shoda před prvním b; najde nulové výskyty "a" a vrátí prázdný řetězec. Třetí shoda nezačíná přesně tam, kde druhá shoda skončila, protože druhá shoda vrátila prázdný řetězec. Místo toho začne o jeden znak později za prvním znakem "b". Třetí shoda najde dva výskyty "a" a vrátí "aa". Čtvrtý pokus o shodu začíná tam, kde třetí shoda skončila před druhou "b" a vrátí prázdný řetězec. Pátý pokus o shodu znovu přejde o jeden znak tak, aby začal před třetí "b" a vrátil prázdný řetězec. Šestá shoda začíná po posledním "b" a vrátí prázdný řetězec znovu.

Platí pro