Model obiektu wyrażenia regularnego

Artykuł
03/13/2024

W tym artykule opisano model obiektów używany podczas pracy z wyrażeniami regularnymi platformy .NET.

Aparat wyrażeń regularnych

Aparat wyrażeń regularnych na platformie .NET jest reprezentowany przez klasę Regex . Aparat wyrażeń regularnych jest odpowiedzialny za analizowanie i kompilowanie wyrażenia regularnego oraz wykonywanie operacji pasujących do wzorca wyrażenia regularnego za pomocą ciągu wejściowego. Aparat jest centralnym składnikiem modelu obiektów wyrażeń regularnych platformy .NET.

Aparat wyrażeń regularnych można używać na jeden z dwóch sposobów:

Wywołując metody Regex statyczne klasy. Parametry metody obejmują ciąg wejściowy i wzorzec wyrażenia regularnego. Aparat wyrażeń regularnych buforuje wyrażenia regularne używane w wywołaniach metod statycznych, dlatego powtarzające się wywołania statycznych metod wyrażeń regularnych, które używają tego samego wyrażenia regularnego, oferują stosunkowo dobrą wydajność.
Tworząc wystąpienie Regex obiektu, czyli przekazując wyrażenie regularne do konstruktora klasy. W tym przypadku Regex obiekt jest niezmienny (tylko do odczytu) i reprezentuje aparat wyrażeń regularnych, który jest ściśle powiązany z pojedynczym wyrażeniem regularnym. Ponieważ wyrażenia regularne używane przez Regex wystąpienia nie są buforowane, nie należy wykonywać Regex wystąpień obiektu wielokrotnie przy użyciu tego samego wyrażenia regularnego.

Metody klasy można wywołać Regex , aby wykonać następujące operacje:

Ustal, czy ciąg pasuje do wzorca wyrażenia regularnego.
Wyodrębnij pojedyncze dopasowanie lub pierwsze dopasowanie.
Wyodrębnij wszystkie dopasowania.
Zastąp pasujący podciąg.
Podziel pojedynczy ciąg na tablicę ciągów.

Te operacje opisano w poniższych sekcjach.

Dopasowywanie wzorca wyrażenia regularnego

Metoda Regex.IsMatch zwraca true wartość , jeśli ciąg jest zgodny ze wzorcem lub false jeśli nie. Metoda IsMatch jest często używana do sprawdzania poprawności danych wejściowych ciągu. Na przykład poniższy kod gwarantuje, że ciąg pasuje do prawidłowego numeru ubezpieczenia społecznego w Stany Zjednoczone.

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

Wzorzec ^\d{3}-\d{2}-\d{4}$ wyrażenia regularnego jest interpretowany, jak pokazano w poniższej tabeli.

Wzorzec	opis
`^`	Dopasuj początek ciągu wejściowego.
`\d{3}`	Dopasowuje trzy cyfry dziesiętne.
`-`	Dopasuj łącznik.
`\d{2}`	Dopasuj dwie cyfry dziesiętne.
`-`	Dopasuj łącznik.
`\d{4}`	Dopasuj cztery cyfry dziesiętne.
`$`	Dopasowuje koniec ciągu wejściowego.

Wyodrębnianie pojedynczego dopasowania lub pierwszego dopasowania

Metoda Regex.Match zwraca Match obiekt zawierający informacje na temat pierwszego podciągu zgodnego ze wzorcem wyrażenia regularnego. Match.Success Jeśli właściwość zwraca truewartość , wskazując, że znaleziono dopasowanie, możesz pobrać informacje o kolejnych dopasowaniach, wywołując metodę Match.NextMatch . Te wywołania metody mogą być kontynuowane do momentu, aż Match.Success właściwość zwróci falsewartość . Na przykład poniższy kod używa Regex.Match(String, String) metody w celu znalezienia pierwszego wystąpienia zduplikowanego wyrazu w ciągu. Następnie wywołuje metodę w celu znalezienia Match.NextMatch dodatkowych wystąpień. W przykładzie Match.Success właściwość jest sprawdzana po każdym wywołaniu metody w celu określenia, czy bieżące dopasowanie zakończyło się powodzeniem i czy należy wykonać wywołanie 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.

Wzorzec \b(\w+)\W+(\1)\b wyrażenia regularnego jest interpretowany, jak pokazano w poniższej tabeli.

Wzorzec	opis
`\b`	Rozpocznij dopasowanie na granicy wyrazu.
`(\w+)`	Dopasowuje co najmniej jeden znak słowa. Jest to pierwsza grupa przechwytywania.
`\W+`	Dopasuj jeden lub więcej znaków innych niż wyrazy.
`(\1)`	Dopasuj pierwszy przechwycony ciąg. Jest to druga grupa przechwytywania.
`\b`	Zakończ dopasowanie na granicy wyrazu.

Wyodrębnianie wszystkich dopasowań

Metoda Regex.Matches zwraca MatchCollection obiekt zawierający informacje o wszystkich dopasowaniach aparatu wyrażeń regularnych znalezionych w ciągu wejściowym. Na przykład poprzedni przykład można przepisać, aby wywołać metodę Matches zamiast Match metod i 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";
      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.

Zastępowanie pasowanego podciągu

Metoda Regex.Replace zastępuje każdy podciąg zgodny ze wzorcem wyrażenia regularnego określonym ciągiem lub wzorcem wyrażenia regularnego i zwraca cały ciąg wejściowy z zamianami. Na przykład poniższy kod dodaje symbol waluty USA przed liczbą dziesiętną w ciągu.

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

Wzorzec \b\d+\.\d{2}\b wyrażenia regularnego jest interpretowany, jak pokazano w poniższej tabeli.

Wzorzec	opis
`\b`	Rozpoczyna dopasowanie na granicy wyrazu.
`\d+`	Dopasowanie do co najmniej jednej cyfry dziesiętnej.
`\.`	Dopasuj kropkę.
`\d{2}`	Dopasuj dwie cyfry dziesiętne.
`\b`	Kończy dopasowanie na granicy wyrazu.

Wzorzec $$$& wymiany jest interpretowany, jak pokazano w poniższej tabeli.

Wzorzec	Ciąg zastępczy
`$$`	Znak dolara ($).
`$&`	Cała dopasowana podciąg.

Dzielenie pojedynczego ciągu na tablicę ciągów

Metoda Regex.Split dzieli ciąg wejściowy na pozycje zdefiniowane przez dopasowanie wyrażenia regularnego. Na przykład poniższy kod umieszcza elementy na liście numerowanej w tablicę ciągów.

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

Wzorzec \b\d{1,2}\.\s wyrażenia regularnego jest interpretowany, jak pokazano w poniższej tabeli.

Wzorzec	opis
`\b`	Rozpoczyna dopasowanie na granicy wyrazu.
`\d{1,2}`	Dopasuj jedną lub dwie cyfry dziesiętne.
`\.`	Dopasuj kropkę.
`\s`	Dopasowuje znak odstępu.

Obiekty `MatchCollection` i `Match`

Metody wyrażenia regularnego zwracają dwa obiekty będące częścią modelu obiektów wyrażeń regularnych: MatchCollection obiekt i Match obiekt.

Klasa `MatchCollection`

Metoda Regex.Matches zwraca MatchCollection obiekt zawierający Match obiekty reprezentujące wszystkie dopasowania znalezione przez aparat wyrażeń regularnych w kolejności, w której występują w ciągu wejściowym. Jeśli nie ma dopasowań, metoda zwraca MatchCollection obiekt bez elementów członkowskich. Właściwość MatchCollection.Item[] umożliwia dostęp do poszczególnych elementów członkowskich kolekcji według indeksu, od zera do jednej mniejszej MatchCollection.Count niż wartość właściwości. Item[] to indeksator kolekcji (w języku C#) i właściwość domyślna (w Visual Basic).

Domyślnie wywołanie metody używa leniwej Regex.Matches oceny w celu wypełnienia MatchCollection obiektu. Dostęp do właściwości wymagających w pełni wypełnionej kolekcji, takiej jak MatchCollection.Count właściwości i MatchCollection.Item[] , może obejmować karę za wydajność. W związku z tym zalecamy uzyskanie dostępu do kolekcji przy użyciu IEnumerator obiektu zwróconego przez metodę MatchCollection.GetEnumerator . Poszczególne języki udostępniają konstrukcje, takie jak For Each w języku Visual Basic i foreach C#, które opakowuje interfejs kolekcji IEnumerator .

W poniższym przykładzie użyto Regex.Matches(String) metody , aby wypełnić MatchCollection obiekt wszystkimi dopasowaniami znalezionymi w ciągu wejściowym. Przykład wylicza kolekcję, kopiuje dopasowania do tablicy ciągów i rejestruje pozycje znaków w tablicy całkowitej.

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.

Klasa `Match`

Klasa Match reprezentuje wynik dopasowania pojedynczego wyrażenia regularnego. Dostęp do obiektów można uzyskać Match na dwa sposoby:

Przez pobranie ich z MatchCollection obiektu, który jest zwracany przez metodę Regex.Matches . Aby pobrać poszczególne Match obiekty, iteruj kolekcję przy użyciu foreach konstrukcji (w języku C#) lub For Each...Next (w języku Visual Basic) lub użyj MatchCollection.Item[] właściwości w celu pobrania określonego Match obiektu według indeksu lub nazwy. Można również pobrać poszczególne Match obiekty z kolekcji, iterując kolekcję według indeksu, od zera do jednego mniejszego niż liczba obiektów w kolekcji. Jednak ta metoda nie korzysta z leniwej oceny, ponieważ uzyskuje MatchCollection.Count dostęp do właściwości .

Poniższy przykład pobiera poszczególne Match obiekty z MatchCollection obiektu, iterując kolekcję przy użyciu foreach konstrukcji lub For Each...Next . Wyrażenie regularne po prostu pasuje do ciągu "abc" w ciągu wejściowym.

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.

Wywołując metodę Regex.Match Match , która zwraca obiekt, który reprezentuje pierwsze dopasowanie w ciągu lub części ciągu. Możesz określić, czy dopasowanie zostało znalezione, pobierając wartość Match.Success właściwości. Aby pobrać Match obiekty reprezentujące kolejne dopasowania, wywołaj metodę Match.NextMatch wielokrotnie, dopóki Success właściwość zwróconego Match obiektu to false.

W poniższym przykładzie użyto Regex.Match(String, String) metod i Match.NextMatch , aby dopasować ciąg "abc" w ciągu wejściowym.

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.

Dwie właściwości Match obiektów kolekcji zwracanej klasy:

Właściwość Match.Groups zwraca GroupCollection obiekt zawierający informacje o podciągach pasujących do grup przechwytywania we wzorcu wyrażenia regularnego.
Właściwość Match.Captures zwraca CaptureCollection obiekt, który jest ograniczony do użycia. Kolekcja nie jest wypełniana dla Match obiektu, którego Success właściwość to false. W przeciwnym razie zawiera pojedynczy Capture obiekt, który zawiera te same informacje co Match obiekt.

Aby uzyskać więcej informacji na temat tych obiektów, zobacz GroupCollectionSekcje klasy i CaptureCollection Klasy w dalszej części tego artykułu.

Dwie dodatkowe właściwości Match klasy zawierają informacje o dopasowaniu. Właściwość Match.Value zwraca podciąg w ciągu wejściowym zgodnym ze wzorcem wyrażenia regularnego. Właściwość Match.Index zwraca pozycję początkową opartą na zera dopasowanego ciągu w ciągu wejściowym.

Klasa Match ma również dwie metody dopasowywania wzorców:

Metoda Match.NextMatch znajduje dopasowanie po dopasowaniu reprezentowanym przez bieżący Match obiekt i zwraca Match obiekt, który reprezentuje to dopasowanie.
Metoda Match.Result wykonuje określoną operację zamiany na dopasowanym ciągu i zwraca wynik.

W poniższym przykładzie Match.Result użyto metody , aby poprzedzać symbol $ i spację przed każdą liczbą zawierającą dwie cyfry ułamkowe.

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

Wzorzec \b\d+(,\d{3})*\.\d{2}\b wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.

Wzorzec	opis
`\b`	Rozpoczyna dopasowanie na granicy wyrazu.
`\d+`	Dopasowanie do co najmniej jednej cyfry dziesiętnej.
`(,\d{3})*`	Dopasuj zero lub więcej wystąpień przecinka, po którym następują trzy cyfry dziesiętne.
`\.`	Dopasuj znak separatora dziesiętnego.
`\d{2}`	Dopasuj dwie cyfry dziesiętne.
`\b`	Kończy dopasowanie na granicy wyrazu.

Wzorzec $$ $& zastępowania wskazuje, że dopasowane podciągy powinny zostać zastąpione symbolem znaku dolara ($) ($$wzorzec), spacją i wartością dopasowania (wzorzec).$&

Klasa `GroupCollection`

Właściwość Match.Groups zwraca GroupCollection obiekt, który zawiera Group obiekty reprezentujące przechwycone grupy w jednym dopasowaniu. Pierwszy Group obiekt w kolekcji (w indeksie 0) reprezentuje całe dopasowanie. Każdy z poniższych obiektów reprezentuje wyniki pojedynczej grupy przechwytywania.

Poszczególne Group obiekty w kolekcji można pobrać przy użyciu GroupCollection.Item[] właściwości . Grupy nienazwane można pobrać według ich pozycji porządkowej w kolekcji i pobrać nazwane grupy według nazwy lub według pozycji porządkowej. Nienazwane przechwytywanie są wyświetlane jako pierwsze w kolekcji i są indeksowane od lewej do prawej w kolejności, w której są wyświetlane we wzorcu wyrażenia regularnego. Nazwane przechwytywanie są indeksowane po nienazwanych przechwytywaniach od lewej do prawej w kolejności, w której są wyświetlane we wzorcu wyrażenia regularnego. Aby określić, jakie grupy numerowane są dostępne w kolekcji zwracanej dla określonej metody dopasowywania wyrażeń regularnych, można wywołać metodę wystąpienia Regex.GetGroupNumbers . Aby określić, jakie nazwane grupy są dostępne w kolekcji, możesz wywołać metodę wystąpienia Regex.GetGroupNames . Obie metody są szczególnie przydatne w procedurach ogólnego przeznaczenia, które analizują dopasowania znalezione przez dowolne wyrażenie regularne.

Właściwość GroupCollection.Item[] jest indeksatorem kolekcji w języku C# i właściwością domyślną obiektu kolekcji w Visual Basic. Oznacza to, że dostęp do poszczególnych Group obiektów można uzyskać za pomocą indeksu (lub nazwy w przypadku nazwanych grup) w następujący sposób:

Group group = match.Groups[ctr];

Dim group As Group = match.Groups(ctr)

W poniższym przykładzie zdefiniowano wyrażenie regularne, które używa konstrukcji grupowania do przechwytywania miesiąca, dnia i roku daty.

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

Wzorzec \b(\w+)\s(\d{1,2}),\s(\d{4})\b wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.

Wzorzec	opis
`\b`	Rozpoczyna dopasowanie na granicy wyrazu.
`(\w+)`	Dopasowuje co najmniej jeden znak słowa. Jest to pierwsza grupa przechwytywania.
`\s`	Dopasowuje znak odstępu.
`(\d{1,2})`	Dopasuj jedną lub dwie cyfry dziesiętne. Jest to druga grupa przechwytywania.
`,`	Dopasuj przecinek.
`\s`	Dopasowuje znak odstępu.
`(\d{4})`	Dopasuj cztery cyfry dziesiętne. Jest to trzecia grupa przechwytywania.
`\b`	Zakończ dopasowanie na granicy wyrazu.

Przechwycona grupa

Klasa Group reprezentuje wynik z pojedynczej grupy przechwytywania. Obiekty grupy reprezentujące grupy przechwytujące zdefiniowane w wyrażeniu regularnym są zwracane przez Item[] właściwość GroupCollection obiektu zwróconego Match.Groups przez właściwość . Właściwość Item[] jest indeksatorem (w języku C#) i właściwością domyślną (w Visual Basic) Group klasy. Można również pobrać poszczególne elementy członkowskie, iterując kolekcję przy użyciu foreach konstrukcji lub For Each . Aby zapoznać się z przykładem, zobacz poprzednią sekcję.

W poniższym przykładzie użyto zagnieżdżonych konstrukcji grupowania do przechwytywania podciągów do grup. Wzorzec (a(b))c wyrażenia regularnego pasuje do ciągu "abc". Przypisuje on podciąg "ab" do pierwszej grupy przechwytywania, a podciąg "b" do drugiej grupy przechwytywania.

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

W poniższym przykładzie użyto nazwanych konstrukcji grupowania do przechwytywania podciągów z ciągu zawierającego dane w formacie "DATANAME:VALUE", który wyrażenie regularne dzieli dwukropek (:).

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

Wzorzec ^(?<name>\w+):(?<value>\w+) wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.

Wzorzec	opis
`^`	Rozpoczyna dopasowanie na początku ciągu wejściowego.
`(?<name>\w+)`	Dopasowuje co najmniej jeden znak słowa. Nazwa tej grupy przechwytywania to `name`.
`:`	Dopasuj dwukropek.
`(?<value>\w+)`	Dopasowuje co najmniej jeden znak słowa. Nazwa tej grupy przechwytywania to `value`.

Właściwości Group klasy zawierają informacje o przechwyconej grupie: Group.Value właściwość zawiera przechwycone podciąg Group.Index , właściwość wskazuje pozycję początkową przechwyconej grupy w tekście wejściowym, Group.Length właściwość zawiera długość przechwyconego tekstu, a Group.Success właściwość wskazuje, czy podciąg pasuje do wzorca zdefiniowanego przez grupę przechwytywania.

Stosowanie kwantyfikatorów do grupy (aby uzyskać więcej informacji, zobacz Quantifiers) modyfikuje relację jednego przechwytywania na grupę przechwytywania na dwa sposoby:

Jeśli element * lub *? kwantyfikator (który określa zero lub więcej dopasowań) jest stosowany do grupy, grupa przechwytywania może nie mieć dopasowania w ciągu wejściowym. Jeśli nie ma przechwyconego tekstu, właściwości Group obiektu są ustawiane, jak pokazano w poniższej tabeli.

Właściwość Grupuj	Wartość
`Success`	`false`
`Value`	String.Empty
`Length`	0

Poniższy przykład stanowi ilustrację. We wzorcu aaa(bbb)*cccwyrażenia regularnego pierwsza grupa przechwytywania (podciąg "bbb") może być dopasowana do zera lub więcej razy. Ponieważ ciąg wejściowy "aaaccc" pasuje do wzorca, grupa przechwytywania nie ma dopasowania.

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.

Kwantyfikatory mogą odpowiadać wielu wystąpieniom wzorca zdefiniowanego przez grupę przechwytywania. W tym przypadku Value właściwości Group i Length obiektu zawierają tylko informacje o ostatnim przechwyconym podciągu. Na przykład następujące wyrażenie regularne pasuje do pojedynczego zdania kończącego się kropką. Używa dwóch konstrukcji grupowania: pierwszy przechwytuje poszczególne wyrazy wraz z znakiem odstępu; drugi przechwytuje poszczególne wyrazy. Jak pokazuje dane wyjściowe z przykładu, chociaż wyrażenie regularne kończy się powodzeniem w przechwytywaniu całego zdania, druga grupa przechwytywania przechwytuje tylko ostatnie słowo.

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

Klasa `CaptureCollection`

Obiekt Group zawiera tylko informacje o ostatnim przechwyceniu. Jednak cały zestaw przechwytywania wykonanych przez grupę przechwytywania jest nadal dostępny z CaptureCollection obiektu zwracanego przez Group.Captures właściwość . Każdy element członkowski kolekcji jest obiektem reprezentującym Capture przechwycenie przechwycone przez grupę przechwytywania w kolejności przechwycenia (i w związku z tym w kolejności dopasowania przechwyconych ciągów od lewej do prawej w ciągu wejściowym). Poszczególne Capture obiekty można pobrać z kolekcji na jeden z dwóch sposobów:

Iterując przez kolekcję przy użyciu konstrukcji, takiej jak foreach (w języku C#) lub For Each (w Visual Basic).
Za pomocą CaptureCollection.Item[] właściwości w celu pobrania określonego obiektu według indeksu. Właściwość Item[] jest właściwością CaptureCollection domyślną obiektu (w Visual Basic) lub indeksatorem (w języku C#).

Jeśli kwantyfikator nie jest stosowany do grupy przechwytywania, CaptureCollection obiekt zawiera pojedynczy Capture obiekt, który jest mało interesujący, ponieważ dostarcza informacje o tym samym dopasowaniu co jego Group obiekt. Jeśli kwantyfikator jest stosowany do grupy przechwytywania, CaptureCollection obiekt zawiera wszystkie przechwytywane przez grupę przechwytywania, a ostatni element członkowski kolekcji reprezentuje to samo przechwytywanie co Group obiekt.

Jeśli na przykład używasz wzorca ((a(b))c)+ wyrażenia regularnego (gdzie + kwantyfikator określa jeden lub więcej dopasowań) do przechwytywania dopasowań z ciągu "abcabcabc", CaptureCollection obiekt dla każdego Group obiektu zawiera trzy elementy członkowskie.

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

W poniższym przykładzie użyto wyrażenia (Abc)+ regularnego do znalezienia co najmniej jednego z kolejnych uruchomień ciągu "Abc" w ciągu "XYZAbcAbcAbcXYZAbcAb". W przykładzie pokazano użycie Group.Captures właściwości w celu zwrócenia wielu grup przechwyconych podciągów.

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

Klasa `Capture`

Klasa Capture zawiera wyniki z pojedynczego przechwytywania podwyrażenia. Właściwość Capture.Value zawiera dopasowany tekst, a Capture.Index właściwość wskazuje położenie na podstawie zera w ciągu wejściowym, na którym rozpoczyna się dopasowane podciąg.

Poniższy przykład analizuje ciąg wejściowy temperatury wybranych miast. Przecinek (",") służy do oddzielania miasta i temperatury, a średnik (";") służy do oddzielania danych poszczególnych miast. Cały ciąg wejściowy reprezentuje jedno dopasowanie. W wzorcu ((\w+(\s\w+)*),(\d+);)+wyrażenia regularnego , który jest używany do analizowania ciągu, nazwa miasta jest przypisywana do drugiej grupy przechwytywania, a temperatura jest przypisywana do czwartej grupy przechwytywania.

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

Wyrażenie regularne jest definiowane, jak pokazano w poniższej tabeli.

Wzorzec	opis
`\w+`	Dopasowuje co najmniej jeden znak słowa.
`(\s\w+)*`	Dopasuj zero lub więcej wystąpień znaku odstępu, po którym następuje co najmniej jeden znak słowa. Ten wzorzec pasuje do nazw miast o wielu wyrazach. Jest to trzecia grupa przechwytywania.
`(\w+(\s\w+)*)`	Dopasuj co najmniej jeden znak wyrazu, po którym następuje zero lub więcej wystąpień znaku odstępu i co najmniej jeden znak słowa. Jest to druga grupa przechwytywania.
`,`	Dopasuj przecinek.
`(\d+)`	Dopasuj co najmniej jedną cyfrę. Jest to czwarta grupa przechwytywania.
`;`	Dopasuj średnik.
`((\w+(\s\w+)*),(\d+);)+`	Dopasuj wzorzec słowa, po którym następują wszelkie dodatkowe wyrazy, po których następuje przecinek, co najmniej jedna cyfra i średnik, jeden lub więcej razy. Jest to pierwsza grupa przechwytywania.

Udostępnij za pośrednictwem

Model obiektu wyrażenia regularnego

Aparat wyrażeń regularnych

Dopasowywanie wzorca wyrażenia regularnego

Wyodrębnianie pojedynczego dopasowania lub pierwszego dopasowania

Wyodrębnianie wszystkich dopasowań

Zastępowanie pasowanego podciągu

Dzielenie pojedynczego ciągu na tablicę ciągów

Obiekty `MatchCollection` i `Match`

Klasa `MatchCollection`

Klasa `Match`

Klasa `GroupCollection`

Przechwycona grupa

Klasa `CaptureCollection`

Klasa `Capture`

Zobacz też

Dodatkowe zasoby

Udostępnij za pośrednictwem

Model obiektu wyrażenia regularnego

Aparat wyrażeń regularnych

Dopasowywanie wzorca wyrażenia regularnego

Wyodrębnianie pojedynczego dopasowania lub pierwszego dopasowania

Wyodrębnianie wszystkich dopasowań

Zastępowanie pasowanego podciągu

Dzielenie pojedynczego ciągu na tablicę ciągów

Obiekty MatchCollection i Match

Klasa MatchCollection

Klasa Match

Klasa GroupCollection

Przechwycona grupa

Klasa CaptureCollection

Klasa Capture

Zobacz też

Dodatkowe zasoby

Obiekty `MatchCollection` i `Match`

Klasa `MatchCollection`

Klasa `Match`

Klasa `GroupCollection`

Klasa `CaptureCollection`

Klasa `Capture`