Objektový model regulárního výrazu

Článek
03/13/2024

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. Modul je centrální komponenta v objektovém modelu regulárního výrazu .NET.

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

Voláním statických Regex metod třídy. 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í instance objektu Regex , to znamená předáním 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 uložené v mezipaměti, neměli Regex byste vytvořit instanci objektu vícekrát se stejným regulárním výrazem.

Metody třídy můžete volat Regex 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ětěr.
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í vstupu řetězce. Například následující kód zajistí, že řetězec odpovídá platnému číslu sociálního pojištění 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("{0} is a valid SSN.", value);
         else
            Console.WriteLine("{0}: Invalid", value);
      }
   }
}
// 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
`^`	Porovná začátek vstupního řetězce.
`\d{3}`	Porovná tři desítkové číslice.
`-`	Porovná spojovník.
`\d{2}`	Porovná dvě desítkové číslice.
`-`	Porovná spojovník.
`\d{4}`	Porovná čtyři desítkové číslice.
`$`	Porovná konec vstupního řetězce.

Extrahování jedné shody nebo první shody

Metoda Regex.Match vrátí Match objekt, který obsahuje informace o prvním podřetěstru, 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á Match.Success vlastnost po každém volání metody, aby určil, zda aktuální shoda byla úspěšná a zda má následovat volání Match.NextMatch metody.

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 '{0}' found at position {1}.",
                           match.Groups[1].Value, 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)`	Porovná 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, které modul regulárních výrazů nalezen ve vstupním řetězci. 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 '{0}' found at position {1}.",
                           match.Groups[1].Value, 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.

Nahrazení odpovídajícího podřetětěce

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`	Začne porovnání 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ý odpovídající podřetětěr.

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

Metoda Regex.Split rozdělí vstupní řetězec na pozicích definovaných shodu regulárního výrazu. Například následující kód umístí položky v číslovaný seznam 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čne 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` objekty

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í Regex.Matches metody používá opožděné vyhodnocení k naplnění objektu MatchCollection . Přístup k vlastnostem, které vyžadují plně naplněnou kolekci, například MatchCollection.Count MatchCollection.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("'{0}' found at position {1}.",
                           results[ctr], 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 představuje výsledek jedné shody 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é objekty z kolekce můžete také načíst Match iterací kolekce podle indexu, od nuly do jedné menší než počet objektů v kolekci. Tato metoda však nevyužívá opoždě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("{0} found at position {1}.",
                           match.Value, 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ím Regex.Match metody, která vrátí Match objekt, který představuje první shodu v řetězci nebo části řetězce. 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, zavolejte Match.NextMatch metodu opakovaně, dokud Success je vlastnost vráceného Match objektu 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("{0} found at position {1}.",
                           match.Value, 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 vrácených Match objektů kolekce třídy:

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, který je omezené použití. 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 Match třídy poskytují informace o shodě. Vlastnost Match.Value vrátí podřetězce ve vstupním řetězci, který odpovídá vzoru regulárního výrazu. Vlastnost Match.Index vrátí počáteční pozici na základě nuly odpovídajícího řetězce ve vstupním řetězci.

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

Metoda Match.NextMatch najde shodu za shodu reprezentovanou aktuálním Match objektem a vrátí Match objekt, který představuje shodu.
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čne porovnání 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.
`\.`	Porovná znak desetinné čárky.
`\d{2}`	Porovná dvě desítkové číslice.
`\b`	Ukončí porovnání na hranici slova.

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

Třída `GroupCollection`

Vlastnost Match.Groups vrátí GroupCollection objekt, který obsahuje Group objekty, které představují zachycené skupiny v jedné shodě. První Group objekt v kolekci (v indexu 0) představuje celou shodu. Každý následující objekt představuje výsledky jedné zachycené skupiny.

Jednotlivé objekty v kolekci můžete načíst Group pomocí GroupCollection.Item[] vlastnosti. Nepojmenované skupiny můžete načíst podle jejich pořadí v kolekci a načíst pojmenované skupiny podle názvu nebo podle pořadí. Nepojmenované zachycení se zobrazí jako první v kolekci a indexují se zleva doprava v pořadí, v jakém se zobrazují 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, jaké čísloované 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 {0}: {1}", 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čne porovnání 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. Seskupování objektů, které představují zachytávání skupin definovaných v regulárním výrazu, jsou vráceny Item[] vlastností objektu GroupCollection vráceného Match.Groups vlastností. 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í nebo For Each konstruktoruforeach. 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 (a(b))c regulárního výrazu odpovídá řetězci "abc". Přiřadí podřetěc "ab" první zachycené skupině a podřetěc "b" druhé skupině zachycení.

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("{0} at position {1}",
                      results[ctr], 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
`^`	Zahájí porovnává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`.
`:`	Porovná 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 u * skupiny použije kvantifikátor *? (který určuje nulovou nebo více shod), nemusí mít zachytávací skupina 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 aaa(bbb)*cccregulárního výrazu může být první zachycená skupina (podřetěc "bbb") spárována nula nebo vícekrát. Vzhledem k tomu, že vstupní řetězec "aaaccc" odpovídá vzoru, skupina zachycení nemá 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: {0}", match.Value);
      if (match.Groups[1].Success)
         Console.WriteLine("Group 1 value: {0}", 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ě Value a Length vlastnosti objektu Group obsahují informace pouze o posledním zachycené podřetětěc. Například následující regulární výraz odpovídá jedné větě, která končí tečkou. Používá dva seskupovací konstrukce: První zachycuje jednotlivá slova spolu s prázdným znakem; druhý zachycuje jednotlivá slova. Jak ukazuje výstup z příkladu, i když regulární výraz úspěšně zachytí celou větu, druhá zachytává skupinu zachycení pouze posledního slova.

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ých skupinou zachycení je však stále k dispozici z objektu CaptureCollection , který je vrácen Group.Captures vlastností. 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). Jednotlivé Capture objekty z kolekce můžete načíst dvěma způsoby:

Iterací kolekce pomocí konstruktoru, jako foreach je (v jazyce C#) nebo For Each (v jazyce Visual Basic).
CaptureCollection.Item[] Pomocí vlastnosti načíst konkrétní objekt 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: '{0}' at position {1}",
                           match.Value, match.Index);
         GroupCollection groups = match.Groups;
         for (int ctr = 0; ctr < groups.Count; ctr++) {
            Console.WriteLine("   Group {0}: '{1}' at position {2}",
                              ctr, groups[ctr].Value, groups[ctr].Index);
            CaptureCollection captures = groups[ctr].Captures;
            for (int ctr2 = 0; ctr2 < captures.Count; ctr2++) {
               Console.WriteLine("      Capture {0}: '{1}' at position {2}",
                                 ctr2, captures[ctr2].Value, 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 po sobě jdoucích spuštění řetězce "Abc" v řetězci "XYZAbcAbcAbcXYZAbcAb". Příklad znázorňuje použití Group.Captures vlastnosti k vrácení více skupin zachycených podřetědců.

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 z jednoho dílčího výrazu zachycení. 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 ((\w+(\s\w+)*),(\d+);)+regulárního výrazu, který se používá k analýze řetězce, se název města přiřadí druhé zachytávané skupině a teplota se přiřadí čtvrté skupině zachycení.

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á skupina zachycení.
`;`	Porovná 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.

Sdílet prostřednictvím

Objektový model regulárního výrazu

Modul regulárních výrazů

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

Extrahování jedné shody nebo první shody

Extrahování všech shod

Nahrazení odpovídajícího podřetětěce

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

Objekty `MatchCollection` a `Match` objekty

Třída `MatchCollection`

Třída `Match`

Třída `GroupCollection`

Zachycená skupina

Třída `CaptureCollection`

Třída `Capture`

Viz také

Další materiály

Sdílet prostřednictvím

Objektový model regulárního výrazu

Modul regulárních výrazů

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

Extrahování jedné shody nebo první shody

Extrahování všech shod

Nahrazení odpovídajícího podřetětěce

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

Objekty MatchCollection a Match objekty

Třída MatchCollection

Třída Match

Třída GroupCollection

Zachycená skupina

Třída CaptureCollection

Třída Capture

Viz také

Další materiály

Objekty `MatchCollection` a `Match` objekty

Třída `MatchCollection`

Třída `Match`

Třída `GroupCollection`

Třída `CaptureCollection`

Třída `Capture`