Objektový model regulárního výrazu

Tento článek popisuje objektový model používaný při práci s regulárními výrazy .NET.

Modul regulárních výrazů

Modul regulárních výrazů v .NET je reprezentován Regex třídou. Modul regulárních výrazů zodpovídá za analýzu a kompilaci regulárního výrazu a za provádění operací, které odpovídají vzoru regulárního výrazu se vstupním řetězcem. Stroj je centrální komponenta v objektovém modelu regulárních výrazů .NET.

Modul regulárních výrazů můžete použít jedním ze dvou způsobů:

• Voláním statických metod třídy Regex. Parametry metody zahrnují vstupní řetězec a vzor regulárního výrazu. Modul regulárních výrazů ukládá do mezipaměti regulární výrazy používané ve volání statických metod, takže opakovaná volání statických metod regulárních výrazů, které používají stejný regulární výraz, nabízejí relativně dobrý výkon.

• Vytvořením instance objektu Regex, tj. předání regulárního výrazu konstruktoru třídy. V tomto případě Regex je objekt neměnný (jen pro čtení) a představuje modul regulárních výrazů, který je úzce svázán s jedním regulárním výrazem. Protože regulární výrazy používané Regex instancemi nejsou ukládané v mezipaměti, neměli byste instanciat objekt Regex vícekrát se stejným regulárním výrazem.

Metody třídy Regex můžete volat k provedení následujících operací:

• Určete, zda řetězec odpovídá vzoru regulárního výrazu.
• Extrahujte jednu shodu nebo první shodu.
• Extrahujte všechny shody.
• Nahraďte odpovídající podřetězec.
• Rozdělte jeden řetězec na pole řetězců.

Tyto operace jsou popsány v následujících částech.

Porovnávání vzoru regulárního výrazu

Metoda Regex.IsMatch vrátí true , pokud řetězec odpovídá vzoru, nebo false pokud ne. Metoda IsMatch se často používá k ověření řetězcového vstupu. Například následující kód zajistí, že řetězec odpovídá platnému číslu sociálního zabezpečení v USA.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] values = { "111-22-3333", "111-2-3333"};
      string pattern = @"^\d{3}-\d{2}-\d{4}$";
      foreach (string value in values) {
         if (Regex.IsMatch(value, pattern))
            Console.WriteLine($"{value} is a valid SSN.");
         else
            Console.WriteLine($"{value}: Invalid");
      }
   }
}
// The example displays the following output:
//       111-22-3333 is a valid SSN.
//       111-2-3333: Invalid

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim values() As String = {"111-22-3333", "111-2-3333"}
        Dim pattern As String = "^\d{3}-\d{2}-\d{4}$"
        For Each value As String In values
            If Regex.IsMatch(value, pattern) Then
                Console.WriteLine("{0} is a valid SSN.", value)
            Else
                Console.WriteLine("{0}: Invalid", value)
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'       111-22-3333 is a valid SSN.
'       111-2-3333: Invalid

Vzor ^\d{3}-\d{2}-\d{4}$ regulárního výrazu je interpretován, jak je znázorněno v následující tabulce.

Vzor	Popis
^	Porovnej začátek vstupního řetězce.
\d{3}	Porovná tři desítkové číslice.
-	Najít spojovník.
\d{2}	Porovná dvě desítkové číslice.
-	Odpovídá spojovníku.
\d{4}	Porovná čtyři desítkové číslice.
$	Odpovídá konci vstupního řetězce.

Extrahejte jednu nebo první shodu

Metoda Regex.Match vrátí Match objekt, který obsahuje informace o prvním podřetězci, který odpovídá vzoru regulárního výrazu. Pokud vlastnost Match.Success vrátí true, označující, že byla nalezena shoda, můžete načíst informace o následných shodách voláním Match.NextMatch metody. Tato volání metody mohou pokračovat, dokud Match.Success vlastnost nevrátí false. Například následující kód používá metodu Regex.Match(String, String) k vyhledání prvního výskytu duplikovaného slova v řetězci. Potom zavolá metodu Match.NextMatch , aby našla všechny další výskyty. Příklad prozkoumá vlastnost Match.Success po každém volání metody, aby určil, zda aktuální shoda byla úspěšná a zda má následovat volání metody Match.NextMatch.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is a a farm that that raises dairy cattle.";
      string pattern = @"\b(\w+)\W+(\1)\b";
      Match match = Regex.Match(input, pattern);
      while (match.Success)
      {
         Console.WriteLine($"Duplicate '{match.Groups[1].Value}' found at position {match.Groups[2].Index}.");
         match = match.NextMatch();
      }
   }
}
// The example displays the following output:
//       Duplicate 'a' found at position 10.
//       Duplicate 'that' found at position 22.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "This is a a farm that that raises dairy cattle."
        Dim pattern As String = "\b(\w+)\W+(\1)\b"
        Dim match As Match = Regex.Match(input, pattern)
        Do While match.Success
            Console.WriteLine("Duplicate '{0}' found at position {1}.", _
                              match.Groups(1).Value, match.Groups(2).Index)
            match = match.NextMatch()
        Loop
    End Sub
End Module
' The example displays the following output:
'       Duplicate 'a' found at position 10.
'       Duplicate 'that' found at position 22.

Vzor \b(\w+)\W+(\1)\b regulárního výrazu je interpretován, jak je znázorněno v následující tabulce.

Vzor	Popis
\b	Zahajte shodu na hranici slova.
(\w+)	Porovná jeden nebo více znaků slova. Toto je první zachytávající skupina.
\W+	Porovná jeden nebo více neslovných znaků.
(\1)	Najdi první zachycený řetězec. Toto je druhá zachytávající skupina.
\b	Ukončete shodu na hranici slova.

Extrahování všech shod

Metoda Regex.Matches vrátí MatchCollection objekt, který obsahuje informace o všech shodách ve vstupním řetězci, které modul regulárních výrazů nalezl. Například předchozí příklad lze přepsat tak, aby volal metodu Matches místo Match metod a NextMatch metod.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is a a farm that that raises dairy cattle.";
      string pattern = @"\b(\w+)\W+(\1)\b";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine($"Duplicate '{match.Groups[1].Value}' found at position {match.Groups[2].Index}.");
   }
}
// The example displays the following output:
//       Duplicate 'a' found at position 10.
//       Duplicate 'that' found at position 22.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "This is a a farm that that raises dairy cattle."
        Dim pattern As String = "\b(\w+)\W+(\1)\b"
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("Duplicate '{0}' found at position {1}.", _
                              match.Groups(1).Value, match.Groups(2).Index)
        Next
    End Sub
End Module
' The example displays the following output:
'       Duplicate 'a' found at position 10.
'       Duplicate 'that' found at position 22.

Nahraďte odpovídající podřetězec

Metoda Regex.Replace nahrazuje každý podřetězce, který odpovídá vzoru regulárního výrazu se zadaným řetězcem nebo vzorem regulárního výrazu, a vrátí celý vstupní řetězec s nahrazeními. Následující kód například přidá symbol měny USA před desetinné číslo v řetězci.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\d+\.\d{2}\b";
      string replacement = "$$$&";
      string input = "Total Cost: 103.64";
      Console.WriteLine(Regex.Replace(input, pattern, replacement));
   }
}
// The example displays the following output:
//       Total Cost: $103.64

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b\d+\.\d{2}\b"
        Dim replacement As String = "$$$&"
        Dim input As String = "Total Cost: 103.64"
        Console.WriteLine(Regex.Replace(input, pattern, replacement))
    End Sub
End Module
' The example displays the following output:
'       Total Cost: $103.64

Vzor \b\d+\.\d{2}\b regulárního výrazu je interpretován, jak je znázorněno v následující tabulce.

Vzor	Popis
\b	Zahajte na hranici slova.
\d+	Porovná jednu nebo více desítkových číslic.
\.	Porovná období.
\d{2}	Porovná dvě desítkové číslice.
\b	Ukončí porovnání na hranici slova.

Vzor nahrazení $$$& se interpretuje, jak je znázorněno v následující tabulce.

Vzor	Náhradní řetězec
$$	Znak dolaru ($).
$&	Celý vyhovující podřetězec.

Rozdělení jednoho řetězce na pole řetězců

Metoda Regex.Split rozdělí vstupní řetězec na pozicích, kde odpovídá regulární výraz. Například následující kód umístí položky do číslovaného seznamu a následně do pole řetězců.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "1. Eggs 2. Bread 3. Milk 4. Coffee 5. Tea";
      string pattern = @"\b\d{1,2}\.\s";
      foreach (string item in Regex.Split(input, pattern))
      {
         if (!String.IsNullOrEmpty(item))
            Console.WriteLine(item);
      }
   }
}
// The example displays the following output:
//       Eggs
//       Bread
//       Milk
//       Coffee
//       Tea

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "1. Eggs 2. Bread 3. Milk 4. Coffee 5. Tea"
        Dim pattern As String = "\b\d{1,2}\.\s"
        For Each item As String In Regex.Split(input, pattern)
            If Not String.IsNullOrEmpty(item) Then
                Console.WriteLine(item)
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'       Eggs
'       Bread
'       Milk
'       Coffee
'       Tea

Vzor \b\d{1,2}\.\s regulárního výrazu je interpretován, jak je znázorněno v následující tabulce.

Vzor	Popis
\b	Začněte porovnání na hranici slova.
\d{1,2}	Porovná jednu nebo dvě desítkové číslice.
\.	Porovná období.
\s	Porovná prázdný znak.

Objekty MatchCollection a Match

Metody Regex vrací dva objekty, které jsou součástí modelu objektu regulárního výrazu: MatchCollection objekt a Match objekt.

Třída MatchCollection

Metoda Regex.Matches vrátí MatchCollection objekt, který obsahuje Match objekty, které představují všechny shody, které modul regulárních výrazů našel, v pořadí, ve kterém se vyskytují ve vstupním řetězci. Pokud neexistují žádné shody, vrátí metoda MatchCollection objekt bez členů. Tato MatchCollection.Item[] vlastnost umožňuje přístup k jednotlivým členům kolekce pomocí indexu, od nuly po jednu menší než hodnota MatchCollection.Count vlastnosti. Item[] je indexer kolekce (v jazyce C#) a výchozí vlastnost (v jazyce Visual Basic).

Ve výchozím nastavení volání metody Regex.Matches používá líné vyhodnocení k naplnění objektu MatchCollection. Přístup k vlastnostem, které vyžadují plně naplněnou kolekci, například MatchCollection.CountMatchCollection.Item[] vlastnosti, může zahrnovat snížení výkonu. V důsledku toho doporučujeme získat přístup k kolekci pomocí objektu IEnumerator , který je vrácen metodou MatchCollection.GetEnumerator . Jednotlivé jazyky poskytují konstrukty, například For Each v jazyce Visual Basic a foreach v jazyce C#, které zabalí rozhraní kolekce IEnumerator .

Následující příklad používá metodu Regex.Matches(String) k naplnění MatchCollection objektu všemi shodami nalezenými ve vstupním řetězci. Příklad vytvoří výčet kolekce, zkopíruje shody do pole řetězců a zaznamenává pozice znaků v celočíselném poli.

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
       MatchCollection matches;
       List<string> results = new List<string>();
       List<int> matchposition = new List<int>();

       // Create a new Regex object and define the regular expression.
       Regex r = new Regex("abc");
       // Use the Matches method to find all matches in the input string.
       matches = r.Matches("123abc4abcd");
       // Enumerate the collection to retrieve all matches and positions.
       foreach (Match match in matches)
       {
          // Add the match string to the string array.
           results.Add(match.Value);
           // Record the character position where the match was found.
           matchposition.Add(match.Index);
       }
       // List the results.
       for (int ctr = 0; ctr < results.Count; ctr++)
         Console.WriteLine($"'{results[ctr]}' found at position {matchposition[ctr]}.");
   }
}
// The example displays the following output:
//       'abc' found at position 3.
//       'abc' found at position 7.

Imports System.Collections.Generic
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim matches As MatchCollection
        Dim results As New List(Of String)
        Dim matchposition As New List(Of Integer)

        ' Create a new Regex object and define the regular expression.
        Dim r As New Regex("abc")
        ' Use the Matches method to find all matches in the input string.
        matches = r.Matches("123abc4abcd")
        ' Enumerate the collection to retrieve all matches and positions.
        For Each match As Match In matches
            ' Add the match string to the string array.
            results.Add(match.Value)
            ' Record the character position where the match was found.
            matchposition.Add(match.Index)
        Next
        ' List the results.
        For ctr As Integer = 0 To results.Count - 1
            Console.WriteLine("'{0}' found at position {1}.", _
                              results(ctr), matchposition(ctr))
        Next
    End Sub
End Module
' The example displays the following output:
'       'abc' found at position 3.
'       'abc' found at position 7.

Třída Match

Třída Match reprezentuje výsledek jednoho shodného regulárního výrazu. K objektům můžete přistupovat Match dvěma způsoby:

• Načtením z objektu MatchCollection, který je vrácen metodou Regex.Matches. Pokud chcete načíst jednotlivé Match objekty, iterujte kolekci pomocí konstruktoru foreach (v jazyce C#) nebo For Each...Next (v jazyce Visual Basic) nebo pomocí MatchCollection.Item[] vlastnosti načtěte konkrétní Match objekt buď pomocí indexu, nebo podle názvu. Jednotlivé Match objekty z kolekce můžete také načíst iterací kolekce podle indexu, od nuly do čísla o jednu menší než počet objektů v kolekci. Tato metoda však nevyužívá líné vyhodnocení, protože přistupuje k MatchCollection.Count vlastnosti.

  Následující příklad načte jednotlivé Match objekty z MatchCollection objektu iterací kolekce pomocí konstruktoru foreach nebo For Each...Next . Regulární výraz jednoduše odpovídá řetězci "abc" ve vstupním řetězci.

  using System;
  using System.Text.RegularExpressions;
  
  public class Example
  {
     public static void Main()
     {
        string pattern = "abc";
        string input = "abc123abc456abc789";
        foreach (Match match in Regex.Matches(input, pattern))
           Console.WriteLine($"{match.Value} found at position {match.Index}.");
     }
  }
  // The example displays the following output:
  //       abc found at position 0.
  //       abc found at position 6.
  //       abc found at position 12.
  

  Imports System.Text.RegularExpressions
  
  Module Example
      Public Sub Main()
          Dim pattern As String = "abc"
          Dim input As String = "abc123abc456abc789"
          For Each match As Match In Regex.Matches(input, pattern)
              Console.WriteLine("{0} found at position {1}.", _
                                match.Value, match.Index)
          Next
      End Sub
  End Module
  ' The example displays the following output:
  '       abc found at position 0.
  '       abc found at position 6.
  '       abc found at position 12.
  

• Volání metody Regex.Match, což vrátí objekt Match, který představuje první shodu v řetězci nebo jeho části. Můžete určit, zda byla nalezena shoda načtením hodnoty Match.Success vlastnosti. Chcete-li načíst Match objekty, které představují následné shody, opakovaně volejte Match.NextMatch metodu, dokud vlastnost Success vráceného Match objektu není false.

  Následující příklad používá Regex.Match(String, String) a Match.NextMatch metody, které odpovídají řetězci "abc" ve vstupním řetězci.

  using System;
  using System.Text.RegularExpressions;
  
  public class Example
  {
     public static void Main()
     {
        string pattern = "abc";
        string input = "abc123abc456abc789";
        Match match = Regex.Match(input, pattern);
        while (match.Success)
        {
           Console.WriteLine($"{match.Value} found at position {match.Index}.");
           match = match.NextMatch();
        }
     }
  }
  // The example displays the following output:
  //       abc found at position 0.
  //       abc found at position 6.
  //       abc found at position 12.
  

  Imports System.Text.RegularExpressions
  
  Module Example
      Public Sub Main()
          Dim pattern As String = "abc"
          Dim input As String = "abc123abc456abc789"
          Dim match As Match = Regex.Match(input, pattern)
          Do While match.Success
              Console.WriteLine("{0} found at position {1}.", _
                                match.Value, match.Index)
              match = match.NextMatch()
          Loop
      End Sub
  End Module
  ' The example displays the following output:
  '       abc found at position 0.
  '       abc found at position 6.
  '       abc found at position 12.
  

Dvě vlastnosti třídy Match vracejí objekty kolekce:

• Vlastnost Match.Groups vrátí GroupCollection objekt, který obsahuje informace o podřetěžcích, které odpovídají zachytávání skupin v vzoru regulárního výrazu.

• Vlastnost Match.Captures vrátí CaptureCollection objekt, jehož použití je omezené. Kolekce není naplněna Match pro objekt, jehož Success vlastnost je false. V opačném případě obsahuje jeden Capture objekt, který má stejné informace jako Match objekt.

Další informace o těchto objektech naleznete v části GroupCollection Třída a Třída CaptureCollection dále v tomto článku.

Dvě další vlastnosti třídy Match poskytují informace o shodě. Vlastnost Match.Value vrátí podřetězec ve vstupním řetězci, který odpovídá vzoru regulárního výrazu. Vlastnost Match.Index vrátí pozici počátku shodného řetězce ve vstupním řetězci, založenou na indexu od nuly.

Třída Match má také dvě metody porovnávání vzorů:

• Metoda Match.NextMatch najde další shodu za tou, kterou reprezentuje aktuální Match objekt, a vrátí Match objekt, který tu shodu reprezentuje.

• Metoda Match.Result provede zadanou operaci nahrazení odpovídajícího řetězce a vrátí výsledek.

Následující příklad používá metodu Match.Result k předpřipravení symbolu $ a mezery před každým číslem, které obsahuje dvě desetinné číslice.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\d+(,\d{3})*\.\d{2}\b";
      string input = "16.32\n194.03\n1,903,672.08";

      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Result("$$ $&"));
   }
}
// The example displays the following output:
//       $ 16.32
//       $ 194.03
//       $ 1,903,672.08

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b\d+(,\d{3})*\.\d{2}\b"
        Dim input As String = "16.32" + vbCrLf + "194.03" + vbCrLf + "1,903,672.08"

        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Result("$$ $&"))
        Next
    End Sub
End Module
' The example displays the following output:
'       $ 16.32
'       $ 194.03
'       $ 1,903,672.08

Vzor regulárního výrazu \b\d+(,\d{3})*\.\d{2}\b je definován, jak je znázorněno v následující tabulce.

Vzor	Popis
\b	Začněte na hranici slova.
\d+	Porovná jednu nebo více desítkových číslic.
(,\d{3})*	Porovná nula nebo více výskytů čárky následované třemi desetinnými číslicemi.
\.	Odpovídá znaku desetinné čárky.
\d{2}	Porovná dvě desítkové číslice.
\b	Ukončit shodu na hranici slova.

Vzor nahrazení $$ $& označuje, že odpovídající podřetězec by měl být nahrazen symbolem dolaru $ (vzor $$), mezerou a hodnotou shody (vzor $&).

Třída GroupCollection

Vlastnost Match.Groups vrátí objekt GroupCollection, který obsahuje objekty Group, jež představují zachycené skupiny v rámci jednoho shodu. První Group objekt v kolekci (v indexu 0) představuje celou shodu. Každý z následujících objektů představuje výsledky jednotlivé zachycené skupiny.

Jednotlivé objekty v kolekci můžete načíst pomocí vlastnosti GroupCollection.Item[]Group. Nepojmenované skupiny můžete načíst podle jejich řadové pozice v kolekci a pojmenované skupiny načíst buď podle názvu, nebo podle řadové pozice. Nepojmenovaná zachycení se v kolekci zobrazují nejprve a indexují se zleva doprava podle pořadí, v jakém se objevují ve vzoru regulárního výrazu. Pojmenované zachycení se indexují po nepojmenovaných zachyceních zleva doprava v pořadí, v jakém se zobrazují ve vzoru regulárního výrazu. Chcete-li zjistit, které očíslované skupiny jsou k dispozici v kolekci vrácené pro konkrétní metodu porovnávání regulárních výrazů, můžete volat metodu instance Regex.GetGroupNumbers. Pokud chcete zjistit, jaké pojmenované skupiny jsou v kolekci k dispozici, můžete volat metodu instance Regex.GetGroupNames . Obě metody jsou zvláště užitečné v rutinách pro obecné účely, které analyzují shody nalezené jakýmkoli regulárním výrazem.

Vlastnost GroupCollection.Item[] je indexer kolekce v jazyce C# a výchozí vlastnost objektu kolekce v jazyce Visual Basic. To znamená, že k jednotlivým Group objektům lze přistupovat pomocí indexu (nebo podle názvu v případě pojmenovaných skupin) následujícím způsobem:

Group group = match.Groups[ctr];

Dim group As Group = match.Groups(ctr)

Následující příklad definuje regulární výraz, který používá seskupovací konstrukty k zachycení měsíce, dne a roku data.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\w+)\s(\d{1,2}),\s(\d{4})\b";
      string input = "Born: July 28, 1989";
      Match match = Regex.Match(input, pattern);
      if (match.Success)
         for (int ctr = 0; ctr <  match.Groups.Count; ctr++)
            Console.WriteLine($"Group {ctr}: {match.Groups[ctr].Value}");
    }
}
// The example displays the following output:
//       Group 0: July 28, 1989
//       Group 1: July
//       Group 2: 28
//       Group 3: 1989

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(\w+)\s(\d{1,2}),\s(\d{4})\b"
        Dim input As String = "Born: July 28, 1989"
        Dim match As Match = Regex.Match(input, pattern)
        If match.Success Then
            For ctr As Integer = 0 To match.Groups.Count - 1
                Console.WriteLine("Group {0}: {1}", ctr, match.Groups(ctr).Value)
            Next
        End If
    End Sub
End Module
' The example displays the following output:
'       Group 0: July 28, 1989
'       Group 1: July
'       Group 2: 28
'       Group 3: 1989

Vzor regulárního výrazu \b(\w+)\s(\d{1,2}),\s(\d{4})\b je definován, jak je znázorněno v následující tabulce.

Vzor	Popis
\b	Začněte shodu na hranici slova.
(\w+)	Porovná jeden nebo více znaků slova. Toto je první zachytávající skupina.
\s	Porovná prázdný znak.
(\d{1,2})	Porovná jednu nebo dvě desítkové číslice. Toto je druhá zachytávající skupina.
,	Porovná čárku.
\s	Porovná prázdný znak.
(\d{4})	Porovná čtyři desítkové číslice. Toto je třetí zachytávající skupina.
\b	Ukončete shodu na hranici slova.

Zachycená skupina

Třída Group představuje výsledek jedné zachycené skupiny. Objekty, které reprezentují zachytávací skupiny definované v regulárním výrazu, jsou vráceny vlastností Item[] objektu, který je vrácen vlastností Match.Groups. Vlastnost Item[] je indexer (v jazyce C#) a výchozí vlastnost (v jazyce Visual Basic) Group třídy. Jednotlivé členy můžete také načíst iterací kolekce pomocí konstrukce foreach nebo For Each. Příklad najdete v předchozí části.

Následující příklad používá vnořené konstrukty seskupení k zachycení podřetězců do skupin. Vzor regulárního výrazu (a(b))c odpovídá na řetězec "abc". Podřetězec "ab" přiřadí první zachycovací skupině a podřetězec "b" druhé zachycovací skupině.

var matchposition = new List<int>();
var results = new List<string>();
// Define substrings abc, ab, b.
var r = new Regex("(a(b))c");
Match m = r.Match("abdabc");
for (int i = 0; m.Groups[i].Value != ""; i++)
{
    // Add groups to string array.
    results.Add(m.Groups[i].Value);
    // Record character position.
    matchposition.Add(m.Groups[i].Index);
}

// Display the capture groups.
for (int ctr = 0; ctr < results.Count; ctr++)
    Console.WriteLine($"{results[ctr]} at position {matchposition[ctr]}");
// The example displays the following output:
//       abc at position 3
//       ab at position 3
//       b at position 4

Dim matchposition As New List(Of Integer)
Dim results As New List(Of String)
' Define substrings abc, ab, b.
Dim r As New Regex("(a(b))c")
Dim m As Match = r.Match("abdabc")
Dim i As Integer = 0
While Not (m.Groups(i).Value = "")
    ' Add groups to string array.
    results.Add(m.Groups(i).Value)
    ' Record character position. 
    matchposition.Add(m.Groups(i).Index)
    i += 1
End While

' Display the capture groups.
For ctr As Integer = 0 to results.Count - 1
    Console.WriteLine("{0} at position {1}", _
                      results(ctr), matchposition(ctr))
Next
' The example displays the following output:
'       abc at position 3
'       ab at position 3
'       b at position 4

Následující příklad používá pojmenované seskupovací konstrukty k zachycení podřetězců z řetězce, který obsahuje data ve formátu "DATANAME:VALUE", který regulární výraz rozdělí na dvojtečku (:).

var r = new Regex(@"^(?<name>\w+):(?<value>\w+)");
Match m = r.Match("Section1:119900");
Console.WriteLine(m.Groups["name"].Value);
Console.WriteLine(m.Groups["value"].Value);
// The example displays the following output:
//       Section1
//       119900

Dim r As New Regex("^(?<name>\w+):(?<value>\w+)")
Dim m As Match = r.Match("Section1:119900")
Console.WriteLine(m.Groups("name").Value)
Console.WriteLine(m.Groups("value").Value)
' The example displays the following output:
'       Section1
'       119900

Vzor regulárního výrazu ^(?<name>\w+):(?<value>\w+) je definován, jak je znázorněno v následující tabulce.

Vzor	Popis
^	Začněte porovnání na začátku vstupního řetězce.
(?<name>\w+)	Porovná jeden nebo více znaků slova. Název této zachycené skupiny je name.
:	Zkontroluje dvojtečku.
(?<value>\w+)	Porovná jeden nebo více znaků slova. Název této zachycené skupiny je value.

Vlastnosti Group třídy poskytují informace o zachycené skupině: Vlastnost Group.Value obsahuje zachycený podřetěc, Group.Index vlastnost označuje počáteční pozici zachycené skupiny ve vstupním textu, Group.Length vlastnost obsahuje délku zachyceného textu a Group.Success vlastnost označuje, zda podřetězděc odpovídal vzoru definovanému skupinou zachycení.

Použití kvantifikátorů ve skupině (další informace viz Kvantifikátory) upraví vztah jednoho zachycení na skupinu zachycení dvěma způsoby:

• Pokud se na skupinu * použije kvantifikátor *? (který specifikuje nula nebo více shod), nemusí mít skupina zachytávání shodu ve vstupním řetězci. Pokud není zachycený text, vlastnosti objektu Group jsou nastaveny, jak je znázorněno v následující tabulce.

  Vlastnost Skupiny	Hodnota
  Success	false
  Value	String.Empty
  Length	0

  V následujícím příkladu je uvedena ukázka. Ve vzoru regulárního výrazu aaa(bbb)*ccc může první zachycená skupina (podřetězec "bbb") odpovídat nula či vícekrát. Vzhledem k tomu, že vstupní řetězec "aaaccc" odpovídá vzoru, zachycovací skupina nezaznamenává shodu.

  using System;
  using System.Text.RegularExpressions;
  
  public class Example
  {
     public static void Main()
     {
        string pattern = "aaa(bbb)*ccc";
        string input = "aaaccc";
        Match match = Regex.Match(input, pattern);
        Console.WriteLine($"Match value: {match.Value}");
        if (match.Groups[1].Success)
           Console.WriteLine($"Group 1 value: {match.Groups[1].Value}");
        else
           Console.WriteLine("The first capturing group has no match.");
     }
  }
  // The example displays the following output:
  //       Match value: aaaccc
  //       The first capturing group has no match.
  

  Imports System.Text.RegularExpressions
  
  Module Example
      Public Sub Main()
          Dim pattern As String = "aaa(bbb)*ccc"
          Dim input As String = "aaaccc"
          Dim match As Match = Regex.Match(input, pattern)
          Console.WriteLine("Match value: {0}", match.Value)
          If match.Groups(1).Success Then
              Console.WriteLine("Group 1 value: {0}", match.Groups(1).Value)
          Else
              Console.WriteLine("The first capturing group has no match.")
          End If
      End Sub
  End Module
  ' The example displays the following output:
  '       Match value: aaaccc
  '       The first capturing group has no match.
  

• Kvantifikátory můžou odpovídat více výskytům vzoru definovaného zachytávací skupinou. V tomto případě vlastnosti Value a Length objektu Group obsahují informace pouze o posledním zachyceném podřetězci. Například následující regulární výraz odpovídá jedné větě, která končí tečkou. Používá dva seskupovací konstrukty: První zachycuje jednotlivá slova spolu s mezerou; druhý zachycuje pouze jednotlivá slova. Jak ukazuje výstup z příkladu, i když regulární výraz úspěšně zachytí celou větu, druhá skupina zachycení zachytí pouze poslední slovo.

  using System;
  using System.Text.RegularExpressions;
  
  public class Example
  {
     public static void Main()
     {
        string pattern = @"\b((\w+)\s?)+\.";
        string input = "This is a sentence. This is another sentence.";
        Match match = Regex.Match(input, pattern);
        if (match.Success)
        {
           Console.WriteLine("Match: " + match.Value);
           Console.WriteLine("Group 2: " + match.Groups[2].Value);
        }
     }
  }
  // The example displays the following output:
  //       Match: This is a sentence.
  //       Group 2: sentence
  

  Imports System.Text.RegularExpressions
  
  Module Example
      Public Sub Main()
          Dim pattern As String = "\b((\w+)\s?)+\."
          Dim input As String = "This is a sentence. This is another sentence."
          Dim match As Match = Regex.Match(input, pattern)
          If match.Success Then
              Console.WriteLine("Match: " + match.Value)
              Console.WriteLine("Group 2: " + match.Groups(2).Value)
          End If
      End Sub
  End Module
  ' The example displays the following output:
  '       Match: This is a sentence.
  '       Group 2: sentence
  

Třída CaptureCollection

Objekt Group obsahuje pouze informace o posledním zachycení. Celá sada zachycení provedená zachycovací skupinou je však stále dostupná z objektu CaptureCollection, který je vrácen vlastností Group.Captures. Každý člen kolekce je Capture objekt, který představuje zachycení provedené skupinou zachycení v pořadí, v jakém byly zachyceny (a proto v pořadí, v jakém byly zachycené řetězce spárovány zleva doprava ve vstupním řetězci). Z kolekce můžete jednotlivé Capture objekty načíst jedním ze dvou způsobů:

• Iterací kolekce pomocí konstrukce, jako je foreach (v jazyce C#) nebo For Each (v jazyce Visual Basic).

• Pomocí vlastnosti CaptureCollection.Item[] pro získání konkrétního objektu podle indexu. Vlastnost Item[] je výchozí vlastnost objektu CaptureCollection (v jazyce Visual Basic) nebo indexer (v jazyce C#).

Pokud se kvantifikátor nepoužije na zachytávací skupinu, CaptureCollection objekt obsahuje jeden Capture objekt, který je málo zajímavý, protože poskytuje informace o stejné shodě jako jeho Group objekt. Pokud je kvantifikátor použit u zachytávací skupiny, CaptureCollection objekt obsahuje všechny zachycení provedené skupinou zachycení a poslední člen kolekce představuje stejný zachycení jako Group objekt.

Pokud například použijete vzor ((a(b))c)+ regulárního výrazu (kde + kvantifikátor určuje jednu nebo více shod) k zachycení shod z řetězce "abcabcabc", CaptureCollection objekt pro každý Group objekt obsahuje tři členy.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "((a(b))c)+";
      string input = "abcabcabc";

      Match match = Regex.Match(input, pattern);
      if (match.Success)
      {
         Console.WriteLine($"Match: '{match.Value}' at position {match.Index}");
         GroupCollection groups = match.Groups;
         for (int ctr = 0; ctr < groups.Count; ctr++) {
            Console.WriteLine($"   Group {ctr}: '{groups[ctr].Value}' at position {groups[ctr].Index}");
            CaptureCollection captures = groups[ctr].Captures;
            for (int ctr2 = 0; ctr2 < captures.Count; ctr2++) {
               Console.WriteLine($"      Capture {ctr2}: '{captures[ctr2].Value}' at position {captures[ctr2].Index}");
            }
         }
      }
   }
}
// The example displays the following output:
//       Match: 'abcabcabc' at position 0
//          Group 0: 'abcabcabc' at position 0
//             Capture 0: 'abcabcabc' at position 0
//          Group 1: 'abc' at position 6
//             Capture 0: 'abc' at position 0
//             Capture 1: 'abc' at position 3
//             Capture 2: 'abc' at position 6
//          Group 2: 'ab' at position 6
//             Capture 0: 'ab' at position 0
//             Capture 1: 'ab' at position 3
//             Capture 2: 'ab' at position 6
//          Group 3: 'b' at position 7
//             Capture 0: 'b' at position 1
//             Capture 1: 'b' at position 4
//             Capture 2: 'b' at position 7

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "((a(b))c)+"
        Dim input As STring = "abcabcabc"

        Dim match As Match = Regex.Match(input, pattern)
        If match.Success Then
            Console.WriteLine("Match: '{0}' at position {1}", _
                              match.Value, match.Index)
            Dim groups As GroupCollection = match.Groups
            For ctr As Integer = 0 To groups.Count - 1
                Console.WriteLine("   Group {0}: '{1}' at position {2}", _
                                  ctr, groups(ctr).Value, groups(ctr).Index)
                Dim captures As CaptureCollection = groups(ctr).Captures
                For ctr2 As Integer = 0 To captures.Count - 1
                    Console.WriteLine("      Capture {0}: '{1}' at position {2}", _
                                      ctr2, captures(ctr2).Value, captures(ctr2).Index)
                Next
            Next
        End If
    End Sub
End Module
' The example displays the following output:
'       Match: 'abcabcabc' at position 0
'          Group 0: 'abcabcabc' at position 0
'             Capture 0: 'abcabcabc' at position 0
'          Group 1: 'abc' at position 6
'             Capture 0: 'abc' at position 0
'             Capture 1: 'abc' at position 3
'             Capture 2: 'abc' at position 6
'          Group 2: 'ab' at position 6
'             Capture 0: 'ab' at position 0
'             Capture 1: 'ab' at position 3
'             Capture 2: 'ab' at position 6
'          Group 3: 'b' at position 7
'             Capture 0: 'b' at position 1
'             Capture 1: 'b' at position 4
'             Capture 2: 'b' at position 7

Následující příklad používá regulární výraz (Abc)+ k vyhledání jednoho nebo více souběžných výskytů řetězce "Abc" uvnitř řetězce "XYZAbcAbcAbcXYZAbcAb". Příklad znázorňuje použití vlastnosti Group.Captures k vrácení více skupin zachycených podřetězců.

int counter;
Match m;
CaptureCollection cc;
GroupCollection gc;

// Look for groupings of "Abc".
var r = new Regex("(Abc)+");
// Define the string to search.
m = r.Match("XYZAbcAbcAbcXYZAbcAb");
gc = m.Groups;

// Display the number of groups.
Console.WriteLine("Captured groups = " + gc.Count.ToString());

// Loop through each group.
for (int i = 0; i < gc.Count; i++)
{
    cc = gc[i].Captures;
    counter = cc.Count;

    // Display the number of captures in this group.
    Console.WriteLine("Captures count = " + counter.ToString());

    // Loop through each capture in the group.
    for (int ii = 0; ii < counter; ii++)
    {
        // Display the capture and its position.
        Console.WriteLine(cc[ii] + "   Starts at character " +
             cc[ii].Index);
    }
}
// The example displays the following output:
//       Captured groups = 2
//       Captures count = 1
//       AbcAbcAbc   Starts at character 3
//       Captures count = 3
//       Abc   Starts at character 3
//       Abc   Starts at character 6
//       Abc   Starts at character 9

Dim counter As Integer
Dim m As Match
Dim cc As CaptureCollection
Dim gc As GroupCollection

' Look for groupings of "Abc".
Dim r As New Regex("(Abc)+")
' Define the string to search.
m = r.Match("XYZAbcAbcAbcXYZAbcAb")
gc = m.Groups

' Display the number of groups.
Console.WriteLine("Captured groups = " & gc.Count.ToString())

' Loop through each group.
Dim i, ii As Integer
For i = 0 To gc.Count - 1
    cc = gc(i).Captures
    counter = cc.Count

    ' Display the number of captures in this group.
    Console.WriteLine("Captures count = " & counter.ToString())

    ' Loop through each capture in the group.            
    For ii = 0 To counter - 1
        ' Display the capture and its position.
        Console.WriteLine(cc(ii).ToString() _
            & "   Starts at character " & cc(ii).Index.ToString())
    Next ii
Next i
' The example displays the following output:
'       Captured groups = 2
'       Captures count = 1
'       AbcAbcAbc   Starts at character 3
'       Captures count = 3
'       Abc   Starts at character 3
'       Abc   Starts at character 6
'       Abc   Starts at character 9  

Třída Capture

Třída Capture obsahuje výsledky ze zachycení jednoho dílčího výrazu. Vlastnost Capture.Value obsahuje odpovídající text a Capture.Index vlastnost označuje pozici založenou na nule ve vstupním řetězci, ve kterém začíná odpovídající podřetězc.

Následující příklad analyzuje vstupní řetězec pro teplotu vybraných měst. Čárka (",") slouží k oddělení města a jeho teploty a k oddělení dat jednotlivých měst se používá středník (;). Celý vstupní řetězec představuje jednu shodu. Ve vzoru regulárního výrazu ((\w+(\s\w+)*),(\d+);)+, který se používá k analýze řetězce, je název města přiřazen druhé zachytávací skupině a teplota je přiřazena čtvrté zachytávací skupině.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "Miami,78;Chicago,62;New York,67;San Francisco,59;Seattle,58;";
      string pattern = @"((\w+(\s\w+)*),(\d+);)+";
      Match match = Regex.Match(input, pattern);
      if (match.Success)
      {
         Console.WriteLine("Current temperatures:");
         for (int ctr = 0; ctr < match.Groups[2].Captures.Count; ctr++)
            Console.WriteLine("{0,-20} {1,3}", match.Groups[2].Captures[ctr].Value,
                              match.Groups[4].Captures[ctr].Value);
      }
   }
}
// The example displays the following output:
//       Current temperatures:
//       Miami                 78
//       Chicago               62
//       New York              67
//       San Francisco         59
//       Seattle               58

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "Miami,78;Chicago,62;New York,67;San Francisco,59;Seattle,58;"
        Dim pattern As String = "((\w+(\s\w+)*),(\d+);)+"
        Dim match As Match = Regex.Match(input, pattern)
        If match.Success Then
            Console.WriteLine("Current temperatures:")
            For ctr As Integer = 0 To match.Groups(2).Captures.Count - 1
                Console.WriteLine("{0,-20} {1,3}", match.Groups(2).Captures(ctr).Value, _
                                  match.Groups(4).Captures(ctr).Value)
            Next
        End If
    End Sub
End Module
' The example displays the following output:
'       Current temperatures:
'       Miami                 78
'       Chicago               62
'       New York              67
'       San Francisco         59
'       Seattle               58

Regulární výraz je definován, jak je znázorněno v následující tabulce.

Vzor	Popis
\w+	Porovná jeden nebo více znaků slova.
(\s\w+)*	Porovná žádný nebo více výskytů prázdného znaku následovaného jedním nebo více znaky slova. Tento vzor odpovídá názvům měst s více slovy. Toto je třetí zachytávající skupina.
(\w+(\s\w+)*)	Porovná jeden nebo více znaků slova následovaných nulou nebo více výskytů prázdného znaku a jednoho nebo více znaků slova. Toto je druhá zachytávající skupina.
,	Porovná čárku.
(\d+)	Porovná jednu nebo více číslic. Toto je čtvrtá zachytávací skupina.
;	Najdi středník.
((\w+(\s\w+)*),(\d+);)+	Porovná vzor slova následovaného všemi dalšími slovy následovanými čárkami, jednou nebo více číslicemi a středníkem. Toto je první zachytávající skupina.

Viz také

• System.Text.RegularExpressions
• Regulární výrazy .NET
• Jazyk regulárních výrazů – stručná referenční dokumentace