Model obiektów wyrażeń regularnychThe Regular Expression Object Model

W tym temacie opisano model obiektów używanych w pracy z wyrażeń regularnych programu .NET.This topic describes the object model used in working with .NET regular expressions. Ten temat zawiera następujące sekcje:It contains the following sections:

Aparat wyrażeń regularnychThe Regular Expression Engine

Aparat wyrażeń regularnych w programie .NET jest reprezentowany przez Regex klasy.The regular expression engine in .NET is represented by the Regex class. Aparat wyrażeń regularnych jest odpowiedzialny za analizowaniem i kompilowaniem wyrażenia regularnego i do wykonywania operacji, które pasują do wzorca wyrażenia regularnego, ciąg wejściowy.The regular expression engine is responsible for parsing and compiling a regular expression, and for performing operations that match the regular expression pattern with an input string. Aparat jest składnikiem centralny model obiektów wyrażeń regularnych platformy .NET.The engine is the central component in the .NET regular expression object model.

Umożliwia aparatowi wyrażeń regularnych w jeden z dwóch sposobów:You can use the regular expression engine in either of two ways:

  • Przez wywołanie metody statyczne Regex klasy.By calling the static methods of the Regex class. Parametry metody obejmują ciąg wejściowy i wzorzec wyrażenia regularnego.The method parameters include the input string and the regular expression pattern. Aparat wyrażeń regularnych buforuje wyrażeń regularnych, które są używane w wywołaniach metody statycznej, więc wielokrotnego wywołania metody statyczne wyrażenie regularne, które używają tego samego wyrażenia regularnego oferują stosunkowo dobrej wydajności.The regular expression engine caches regular expressions that are used in static method calls, so repeated calls to static regular expression methods that use the same regular expression offer relatively good performance.

  • Przez utworzenie wystąpienia Regex obiektu, przekazując wyrażeń regularnych do konstruktora klasy.By instantiating a Regex object, by passing a regular expression to the class constructor. W tym przypadku Regex obiektu jest niezmienny (tylko do odczytu) i reprezentuje aparat wyrażeń regularnych, który jest ściśle powiązany z pojedynczego wyrażenia regularnego.In this case, the Regex object is immutable (read-only) and represents a regular expression engine that is tightly coupled with a single regular expression. Ponieważ wyrażenia regularne, używany przez Regex wystąpienia nie są buforowane, nie należy utworzyć wystąpienia Regex obiektów wiele razy z tym samym wyrażeniem regularnym.Because regular expressions used by Regex instances are not cached, you should not instantiate a Regex object multiple times with the same regular expression.

Można wywołać metody Regex klasy, aby wykonywać następujące operacje:You can call the methods of the Regex class to perform the following operations:

  • Określ, czy ciąg jest zgodny z wzorcem wyrażenia regularnego.Determine whether a string matches a regular expression pattern.

  • Wyodrębnij pojedynczego dopasowania lub pierwsze dopasowanie.Extract a single match or the first match.

  • Wyodrębnij wszystkie dopasowania.Extract all matches.

  • Zastąp dopasowanego podciągu.Replace a matched substring.

  • Podziel pojedynczy ciąg na tablicę ciągów.Split a single string into an array of strings.

Te operacje są opisane w poniższych sekcjach.These operations are described in the following sections.

Pasujące do wzorca wyrażenia regularnegoMatching a Regular Expression Pattern

Regex.IsMatch Metoda zwraca true Jeśli ciąg pasuje do wzorca lub false Jeśli tak nie jest.The Regex.IsMatch method returns true if the string matches the pattern, or false if it does not. IsMatch Metoda jest często używana do zweryfikowania ciąg wejściowy.The IsMatch method is often used to validate string input. Na przykład poniższy kod zapewnia zgodność ciąg prawidłowy numer ubezpieczenia społecznego w Stanach Zjednoczonych.For example, the following code ensures that a string matches a valid social security number in the United States.

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

Definicję wzorca wyrażenia regularnego ^\d{3}-\d{2}-\d{4}$ jest interpretowane tak jak pokazano w poniższej tabeli.The regular expression pattern ^\d{3}-\d{2}-\d{4}$ is interpreted as shown in the following table.

WzorzecPattern OpisDescription
^ Dopasowuje początek ciągu wejściowego.Match the beginning of the input string.
\d{3} Dopasowuje trzy cyfry dziesiętne.Match three decimal digits.
- Dopasowuje łącznik.Match a hyphen.
\d{2} Dopasowuje dwie cyfry dziesiętne.Match two decimal digits.
- Dopasowuje łącznik.Match a hyphen.
\d{4} Odpowiada czterem cyfrom po przecinku.Match four decimal digits.
$ Dopasowuje koniec ciągu wejściowego.Match the end of the input string.

Trwa wyodrębnianie pojedynczego dopasowania lub pierwsze dopasowanieExtracting a Single Match or the First Match

Regex.Match Metoda zwraca Match obiektu, który zawiera informacje dotyczące pierwszego podciągu, który jest zgodny ze wzorcem wyrażenia regularnego.The Regex.Match method returns a Match object that contains information about the first substring that matches a regular expression pattern. Jeśli Match.Success właściwość zwraca true, wskazującą, czy znaleziono dopasowanie, można pobrać informacji o kolejnych dopasowań, wywołując Match.NextMatch metody.If the Match.Success property returns true, indicating that a match was found, you can retrieve information about subsequent matches by calling the Match.NextMatch method. Wywołania tych metod można kontynuować do momentu Match.Success właściwość zwraca false.These method calls can continue until the Match.Success property returns false. Na przykład, poniższy kod używa Regex.Match(String, String) metody do znalezienia pierwszego wystąpienia wyrazu zduplikowane w ciągu.For example, the following code uses the Regex.Match(String, String) method to find the first occurrence of a duplicated word in a string. Następnie wywołuje Match.NextMatch metody do znalezienia wszelkie dodatkowe wystąpienia.It then calls the Match.NextMatch method to find any additional occurrences. Przykład sprawdza, czy Match.Success właściwości po każdego wywołania metody, aby określić, czy bieżące dopasowanie zakończyło się pomyślnie i zezwolić wywołaniu Match.NextMatch metody należy wykonać.The example examines the Match.Success property after each method call to determine whether the current match was successful and whether a call to the Match.NextMatch method should follow.

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.

Definicję wzorca wyrażenia regularnego \b(\w+)\W+(\1)\b jest interpretowane tak jak pokazano w poniższej tabeli.The regular expression pattern \b(\w+)\W+(\1)\b is interpreted as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna dopasowanie na granicy wyrazu.Begin the match on a word boundary.
(\w+) Dopasowuje co najmniej jeden znak słowa.Match one or more word characters. Jest to pierwsza grupa przechwytywania.This is the first capturing group.
\W+ Dopasowuje znaki niebędące znakami słowa jeden lub więcej.Match one or more non-word characters.
(\1) Pasuje do pierwszej przechwyconej ciągu.Match the first captured string. Jest to druga grupa przechwytywania.This is the second capturing group.
\b Zakończ dopasowanie na granicy wyrazu.End the match on a word boundary.

Trwa wyodrębnianie wszystkie dopasowaniaExtracting All Matches

Regex.Matches Metoda zwraca MatchCollection obiektu, który zawiera informacje o wszystkie dopasowania, które aparat wyrażeń regularnych znalezione w ciągu wejściowym.The Regex.Matches method returns a MatchCollection object that contains information about all matches that the regular expression engine found in the input string. Na przykład poprzedni przykład można dopasować do wywołania Matches zamiast metody Match i NextMatch metody.For example, the previous example could be rewritten to call the Matches method instead of the Match and NextMatch methods.

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 dopasowanego podciąguReplacing a Matched Substring

Regex.Replace Metoda zastępuje każdy podciągu, który pasuje do wzorca wyrażenia regularnego przy użyciu określonego ciągu lub wzorca wyrażenia regularnego i zwraca cały ciąg wejściowy o zamiany.The Regex.Replace method replaces each substring that matches the regular expression pattern with a specified string or regular expression pattern, and returns the entire input string with replacements. Na przykład poniższy kod dodaje symbol waluty Stanów Zjednoczonych, zanim liczba dziesiętna w ciągu.For example, the following code adds a U.S. currency symbol before a decimal number in a string.

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

Definicję wzorca wyrażenia regularnego \b\d+\.\d{2}\b jest interpretowane tak jak pokazano w poniższej tabeli.The regular expression pattern \b\d+\.\d{2}\b is interpreted as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna dopasowanie na granicy wyrazu.Begin the match at a word boundary.
\d+ Dopasowanie do co najmniej jednej cyfry dziesiętnej.Match one or more decimal digits.
\. Dopasowanie kropki.Match a period.
\d{2} Dopasowuje dwie cyfry dziesiętne.Match two decimal digits.
\b Kończy dopasowanie na granicy wyrazu.End the match at a word boundary.

Wzorzec zamieniania $$$& jest interpretowane tak jak pokazano w poniższej tabeli.The replacement pattern $$$& is interpreted as shown in the following table.

WzorzecPattern Ciąg zastępującyReplacement string
$$ Znak dolara ($).The dollar sign ($) character.
$& Całego dopasowanego podciągu.The entire matched substring.

Dzielenie pojedynczego ciągu na tablicę ciągówSplitting a Single String into an Array of Strings

Regex.Split Metoda dzieli ciąg wejściowy w pozycjach zdefiniowane przez dopasowanie wyrażenia regularnego.The Regex.Split method splits the input string at the positions defined by a regular expression match. Na przykład poniższy kod umieszcza elementy listy numerowanej w tablicy ciągów.For example, the following code places the items in a numbered list into a string array.

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

Definicję wzorca wyrażenia regularnego \b\d{1,2}\.\s jest interpretowane tak jak pokazano w poniższej tabeli.The regular expression pattern \b\d{1,2}\.\s is interpreted as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna dopasowanie na granicy wyrazu.Begin the match at a word boundary.
\d{1,2} Dopasowuje co najmniej dwie cyfry dziesiętne.Match one or two decimal digits.
\. Dopasowanie kropki.Match a period.
\s Dopasowuje znak odstępu.Match a white-space character.

Matchcollection — i dopasuj obiektyThe MatchCollection and Match Objects

Wyrażenie regularne metody zwracają dwa obiekty, które są częścią model obiektów wyrażeń regularnych: MatchCollection obiektu, a Match obiektu.Regex methods return two objects that are part of the regular expression object model: the MatchCollection object, and the Match object.

Kolekcja dopasowaniaThe Match Collection

Regex.Matches Metoda zwraca MatchCollection obiekt, który zawiera Match obiekty reprezentujące wszystkie dopasowania, które zostały odnalezione aparat wyrażeń regularnych, w kolejności, w jakiej występują one w ciągu wejściowym.The Regex.Matches method returns a MatchCollection object that contains Match objects that represent all the matches that the regular expression engine found, in the order in which they occur in the input string. Jeśli brak dopasowań, metoda zwraca MatchCollection obiektu bez członków.If there are no matches, the method returns a MatchCollection object with no members. MatchCollection.Item[Int32] Właściwości zapewnia dostęp do poszczególnych elementów członkowskich kolekcji za pomocą indeksu, od zera do mniejszej o jeden od wartości MatchCollection.Count właściwości.The MatchCollection.Item[Int32] property lets you access individual members of the collection by index, from zero to one less than the value of the MatchCollection.Count property. Item[Int32] to kolekcji indeksatora (w języku C#) i właściwość domyślną (w języku Visual Basic).Item[Int32] is the collection's indexer (in C#) and default property (in Visual Basic).

Domyślnie, wywołanie Regex.Matches metoda użyje obliczanie z opóźnieniem, aby wypełnić MatchCollection obiektu.By default, the call to the Regex.Matches method uses lazy evaluation to populate the MatchCollection object. Dostęp do właściwości, które wymagają całkowicie wypełnione kolekcji, takie jak MatchCollection.Count i MatchCollection.Item[Int32] właściwości, mogą powodować spadek wydajności.Access to properties that require a fully populated collection, such as the MatchCollection.Count and MatchCollection.Item[Int32] properties, may involve a performance penalty. W rezultacie firma Microsoft zaleca uzyskać dostęp do kolekcji przy użyciu IEnumerator obiektu, który jest zwracany przez MatchCollection.GetEnumerator metody.As a result, we recommend that you access the collection by using the IEnumerator object that is returned by the MatchCollection.GetEnumerator method. Poszczególne języki zapewniają konstrukcji, takich jak For Each w języku Visual Basic i foreach w języku C#, opakowywanie zbioru IEnumerator interfejsu.Individual languages provide constructs, such as For Each in Visual Basic and foreach in C#, that wrap the collection's IEnumerator interface.

W poniższym przykładzie użyto Regex.Matches(String) metodę, aby wypełnić MatchCollection obiektu z wszystkie dopasowania w ciągu wejściowym.The following example uses the Regex.Matches(String) method to populate a MatchCollection object with all the matches found in an input string. Przykład wylicza kolekcji, kopiuje dopasowania na tablicę ciągów i rejestruje pozycji znaku w tablicę liczb całkowitych.The example enumerates the collection, copies the matches to a string array, and records the character positions in an integer array.

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.

DopasowanieThe Match

Match Klasa przedstawia wynik dopasowania pojedynczego wyrażenia regularnego.The Match class represents the result of a single regular expression match. Możesz uzyskać dostęp Match obiektów na dwa sposoby:You can access Match objects in two ways:

  • Pobierając je z MatchCollection obiektu, który jest zwracany przez Regex.Matches metody.By retrieving them from the MatchCollection object that is returned by the Regex.Matches method. Aby pobrać poszczególne Match obiektów iteracji kolekcji za pomocą foreach (w języku C#) lub For Each... Next (w języku Visual Basic) konstrukcja lub użyj MatchCollection.Item[Int32] właściwość służąca do pobierania określonej Match obiektu za pomocą indeksu lub według nazwy.To retrieve individual Match objects, iterate the collection by using a foreach (in C#) or For Each...Next (in Visual Basic) construct, or use the MatchCollection.Item[Int32] property to retrieve a specific Match object either by index or by name. Możesz również pobrać poszczególne Match obiektów z kolekcji, iteracja kolekcji za pomocą indeksu, od zera do jednego mniej, liczbę obiektów w kolekcji.You can also retrieve individual Match objects from the collection by iterating the collection by index, from zero to one less that the number of objects in the collection. Jednak ta metoda nie korzystać z opóźnieniem, ponieważ uzyskuje dostęp do MatchCollection.Count właściwości.However, this method does not take advantage of lazy evaluation, because it accesses the MatchCollection.Count property.

    Poniższy przykład pobiera poszczególnych Match obiekty MatchCollection obiektu przez Iterowanie za pomocą kolekcji foreach lub For Each... Next konstruowania.The following example retrieves individual Match objects from a MatchCollection object by iterating the collection using the foreach or For Each...Next construct. Po prostu wyrażenia regularnego pasuje do ciągu "abc" w ciągu wejściowym.The regular expression simply matches the string "abc" in the input string.

    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.
    
  • Przez wywołanie metody Regex.Match metody, która zwraca Match obiekt, który reprezentuje pierwsze dopasowanie w ciągu lub część ciągu.By calling the Regex.Match method, which returns a Match object that represents the first match in a string or a portion of a string. Można określić, czy zostały znalezione dopasowanie poprzez pobranie wartości Match.Success właściwości.You can determine whether the match has been found by retrieving the value of the Match.Success property. Można pobrać Match obiektami, które reprezentują kolejne są zgodne, wywołanie Match.NextMatch metoda wielokrotnie, dopóki Success właściwości zwracanego Match obiekt jest false.To retrieve Match objects that represent subsequent matches, call the Match.NextMatch method repeatedly, until the Success property of the returned Match object is false.

    W poniższym przykładzie użyto Regex.Match(String, String) i Match.NextMatch metody pasuje do ciągu "abc" w ciągu wejściowym.The following example uses the Regex.Match(String, String) and Match.NextMatch methods to match the string "abc" in the input string.

    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 zwracanej kolekcji obiektów klasy:Two properties of the Match class return collection objects:

  • Match.Groups Właściwość zwraca GroupCollection obiekt, który zawiera informacje, które odpowiadają przechwytywania podciągów grup we wzorcu wyrażenia regularnego.The Match.Groups property returns a GroupCollection object that contains information about the substrings that match capturing groups in the regular expression pattern.

  • Match.Captures Właściwość zwraca CaptureCollection obiektu, który ma ograniczone użycie.The Match.Captures property returns a CaptureCollection object that is of limited use. Kolekcja jest pusta dla Match którego Success właściwość false.The collection is not populated for a Match object whose Success property is false. W przeciwnym razie zawiera pojedynczy Capture obiekt, który ma te same informacje co Match obiektu.Otherwise, it contains a single Capture object that has the same information as the Match object.

Aby uzyskać więcej informacji na temat tych obiektów, zobacz kolekcji grupy i kolekcji przechwytywania sekcje w dalszej części tego tematu.For more information about these objects, see The Group Collection and The Capture Collection sections later in this topic.

Dwa dodatkowe właściwości Match klasy zawierają informacje o zgodności.Two additional properties of the Match class provide information about the match. Match.Value Właściwość zwraca podciąg ciągu wejściowego, który pasuje do wzorca wyrażenia regularnego.The Match.Value property returns the substring in the input string that matches the regular expression pattern. Match.Index Właściwość zwraca liczony od zera pozycja początkowa dopasowanego ciągu do ciągu wejściowego.The Match.Index property returns the zero-based starting position of the matched string in the input string.

Match Klasa ma również dwie metody dopasowania do wzorca:The Match class also has two pattern-matching methods:

  • Match.NextMatch Metoda znajdzie dopasowanie, po dopasowaniu reprezentowany przez bieżącą Match obiektu i zwraca Match obiekt, który reprezentuje zgodnych.The Match.NextMatch method finds the match after the match represented by the current Match object, and returns a Match object that represents that match.

  • Match.Result Metoda wykonuje określoną zamieniania na dopasowany ciąg i zwraca wynik.The Match.Result method performs a specified replacement operation on the matched string and returns the result.

W poniższym przykładzie użyto Match.Result metody dołączana $ symbol i spacji przed każdy numer, który zawiera dwie cyfry ułamkowe.The following example uses the Match.Result method to prepend a $ symbol and a space before every number that includes two fractional digits.

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

Definicję wzorca wyrażenia regularnego \b\d+(,\d{3})*\.\d{2}\b jest zdefiniowany jak pokazano w poniższej tabeli.The regular expression pattern \b\d+(,\d{3})*\.\d{2}\b is defined as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna dopasowanie na granicy wyrazu.Begin the match at a word boundary.
\d+ Dopasowanie do co najmniej jednej cyfry dziesiętnej.Match one or more decimal digits.
(,\d{3})* Dopasowuje zero lub więcej wystąpień przecinek następują trzy cyfry dziesiętne.Match zero or more occurrences of a comma followed by three decimal digits.
\. Dopasowuje znak przecinka dziesiętnego.Match the decimal point character.
\d{2} Dopasowuje dwie cyfry dziesiętne.Match two decimal digits.
\b Kończy dopasowanie na granicy wyrazu.End the match at a word boundary.

Wzorzec zamieniania $$ $& wskazuje, że dopasowany podciąg powinna zostać zastąpiona przez symbol znaku dolara ($) ( $$ wzorca), spację, a wartość dopasowania ( $& wzorca).The replacement pattern $$ $& indicates that the matched substring should be replaced by a dollar sign ($) symbol (the $$ pattern), a space, and the value of the match (the $& pattern).

Powrót do początkuBack to top

Kolekcja grupyThe Group Collection

Match.Groups Właściwość zwraca GroupCollection obiekt, który zawiera Group obiekty reprezentujące przechwyconych grupach w pojedyncze dopasowanie.The Match.Groups property returns a GroupCollection object that contains Group objects that represent captured groups in a single match. Pierwszy Group obiektu w kolekcji (pod indeksem 0) reprezentuje całego dopasowania.The first Group object in the collection (at index 0) represents the entire match. Każdy obiekt, który następuje po reprezentuje wyniki pojedynczą grupę przechwytywania.Each object that follows represents the results of a single capturing group.

Możesz pobrać poszczególne Group obiektów w kolekcji przy użyciu GroupCollection.Item[String] właściwości.You can retrieve individual Group objects in the collection by using the GroupCollection.Item[String] property. Możesz pobrać nienazwanych grup według ich pozycji numer porządkowy w kolekcji i pobrać nazwane grupy według nazwy lub porządkowym.You can retrieve unnamed groups by their ordinal position in the collection, and retrieve named groups either by name or by ordinal position. Nienazwane przechwytywania występować jako pierwszy w kolekcji i są indeksowane od lewej do prawej w kolejności, w jakiej są wyświetlane we wzorcu wyrażenia regularnego.Unnamed captures appear first in the collection, and are indexed from left to right in the order in which they appear in the regular expression pattern. Nazwane przechwytywania są indeksowane po nienazwane przechwytywania, od lewej do prawej w kolejności, w jakiej są wyświetlane we wzorcu wyrażenia regularnego.Named captures are indexed after unnamed captures, from left to right in the order in which they appear in the regular expression pattern. Aby ustalić, jakie numerowanej grupy są dostępne w zbiorze zwróconym dla poszczególnych wyrażeń regularnych, metoda wykonująca dopasowanie, należy wywołać wystąpienie Regex.GetGroupNumbers metody.To determine what numbered groups are available in the collection returned for a particular regular expression matching method, you can call the instance Regex.GetGroupNumbers method. Aby ustalić, jakie nazwane grupy są dostępne w kolekcji, należy wywołać wystąpienie Regex.GetGroupNames metody.To determine what named groups are available in the collection, you can call the instance Regex.GetGroupNames method. Obie metody są szczególnie przydatne w procedury ogólnego przeznaczenia, które analizują dopasowań znalezionych przez dowolne wyrażenie regularne.Both methods are particularly useful in general-purpose routines that analyze the matches found by any regular expression.

GroupCollection.Item[String] Właściwość jest indeksator kolekcji w języku C# i obiekt kolekcji domyślnej właściwości w języku Visual Basic.The GroupCollection.Item[String] property is the indexer of the collection in C# and the collection object's default property in Visual Basic. Oznacza to, że osoba Group obiekty są dostępne za pomocą indeksu (lub według nazwy, a w przypadku nazwanych grup) w następujący sposób:This means that individual Group objects can be accessed by index (or by name, in the case of named groups) as follows:

Group group = match.Groups[ctr];         
Dim group As Group = match.Groups(ctr)         

W poniższym przykładzie zdefiniowano wyrażenie regularne, używany przez konstrukcje grupujące do przechwytywania, dzień, miesiąc i rok z daty.The following example defines a regular expression that uses grouping constructs to capture the month, day, and year of a date.

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

Definicję wzorca wyrażenia regularnego \b(\w+)\s(\d{1,2}),\s(\d{4})\b jest zdefiniowany jak pokazano w poniższej tabeli.The regular expression pattern \b(\w+)\s(\d{1,2}),\s(\d{4})\b is defined as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna dopasowanie na granicy wyrazu.Begin the match at a word boundary.
(\w+) Dopasowuje co najmniej jeden znak słowa.Match one or more word characters. Jest to pierwsza grupa przechwytywania.This is the first capturing group.
\s Dopasowuje znak odstępu.Match a white-space character.
(\d{1,2}) Dopasowuje co najmniej dwie cyfry dziesiętne.Match one or two decimal digits. Jest to druga grupa przechwytywania.This is the second capturing group.
, Odpowiada wartości przecinkami.Match a comma.
\s Dopasowuje znak odstępu.Match a white-space character.
(\d{4}) Odpowiada czterem cyfrom po przecinku.Match four decimal digits. Jest to trzecia grupa przechwytywania.This is the third capturing group.
\b Zakończ dopasowanie na granicy wyrazu.End the match on a word boundary.

Powrót do początkuBack to top

Przechwyconą grupęThe Captured Group

Group Klasa przedstawia wynik z pojedynczą grupę przechwytywania.The Group class represents the result from a single capturing group. Obiekty grupy, które reprezentują grupy przechwytywania zdefiniowany w wyrażeniu regularnym są zwracane przez Item[String] właściwość GroupCollection obiektu zwróconego przez Match.Groups właściwości.Group objects that represent the capturing groups defined in a regular expression are returned by the Item[String] property of the GroupCollection object returned by the Match.Groups property. Item[String] Właściwość jest indeksatora (w języku C#) i domyślną właściwość (w języku Visual Basic) Group klasy.The Item[String] property is the indexer (in C#) and the default property (in Visual Basic) of the Group class. Możesz również pobrać poszczególnych elementów członkowskich według Iterowanie za pomocą kolekcji foreach lub For Each konstruowania.You can also retrieve individual members by iterating the collection using the foreach or For Each construct. Aby uzyskać przykład zobacz poprzednią sekcję.For an example, see the previous section.

W poniższym przykładzie użyto konstrukcji zagnieżdżonego grupowania do przechwytywania podciągów w grupach.The following example uses nested grouping constructs to capture substrings into groups. Definicję wzorca wyrażenia regularnego (a(b))c pasuje do ciągu "abc".The regular expression pattern (a(b))c matches the string "abc". Przypisuje podciągu "ab" pierwszą grupę przechwytywania i podciąg "b" do drugiej grupy przechwytywania.It assigns the substring "ab" to the first capturing group, and the substring "b" to the second capturing group.

   List<int> matchposition = new List<int>();
   List<string> results = new List<string>();
   // Define substrings abc, ab, b.
   Regex 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 konstrukcji grupowania nazwanych do przechwytywania podciągów z ciągu, który zawiera dane w formacie "DATANAME:VALUE", który przeszedł wyrażenia regularnego dwukropek (:).The following example uses named grouping constructs to capture substrings from a string that contains data in the format "DATANAME:VALUE", which the regular expression splits at the colon (:).

Regex 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

Definicję wzorca wyrażenia regularnego ^(?<name>\w+):(?<value>\w+) jest zdefiniowany jak pokazano w poniższej tabeli.The regular expression pattern ^(?<name>\w+):(?<value>\w+) is defined as shown in the following table.

WzorzecPattern OpisDescription
^ Rozpoczyna dopasowanie na początku ciągu wejściowego.Begin the match at the beginning of the input string.
(?<name>\w+) Dopasowuje co najmniej jeden znak słowa.Match one or more word characters. Nazwa tej grupy przechwytywania jest name.The name of this capturing group is name.
: Dopasowuje dwukropka.Match a colon.
(?<value>\w+) Dopasowuje co najmniej jeden znak słowa.Match one or more word characters. Nazwa tej grupy przechwytywania jest value.The name of this capturing group is value.

Właściwości Group klasy zawierają informacje o przechwyconej grupy: Group.Value Właściwość zawiera podciąg przechwycony Group.Index właściwość wskazuje pozycję początkową przechwyconej grupy w tekście wejściowym Group.Length właściwość zawiera długość przechwytywany tekst i Group.Success Właściwość wskazuje, czy podciąg dopasowany wzorzec zdefiniowany przez grupę przechwytywania.The properties of the Group class provide information about the captured group: The Group.Value property contains the captured substring, the Group.Index property indicates the starting position of the captured group in the input text, the Group.Length property contains the length of the captured text, and the Group.Success property indicates whether a substring matched the pattern defined by the capturing group.

Stosowanie Kwantyfikatory do grupy (Aby uzyskać więcej informacji, zobacz Kwantyfikatory) modyfikuje relację jednego przechwytywania na przechwytywanie grupy na dwa sposoby:Applying quantifiers to a group (for more information, see Quantifiers) modifies the relationship of one capture per capturing group in two ways:

  • Jeśli * lub *? kwantyfikator (który określa zero lub więcej dopasowań) jest stosowany do grupy, grupa przechwytywania nie może mieć dopasowania w ciągu wejściowym.If the * or *? quantifier (which specifies zero or more matches) is applied to a group, a capturing group may not have a match in the input string. Gdy nie ma żadnego tekstu przechwyconych właściwości Group obiektu są ustawione, jak pokazano w poniższej tabeli.When there is no captured text, the properties of the Group object are set as shown in the following table.

    Właściwości grupyGroup property WartośćValue
    Success false
    Value String.Empty
    Length 00

    Poniższy przykład stanowi ilustrację.The following example provides an illustration. We wzorcu wyrażenia regularnego aaa(bbb)*ccc, pierwszą grupę przechwytywania (podciąg "bbb") można dopasować zero lub więcej razy.In the regular expression pattern aaa(bbb)*ccc, the first capturing group (the substring "bbb") can be matched zero or more times. Ponieważ ciąg wejściowy "aaaccc" pasuje do wzorca, grupa przechwytywania nie ma dopasowania.Because the input string "aaaccc" matches the pattern, the capturing group does not have a match.

    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 może odnosić się wiele wystąpień wzorzec, który jest definiowany przez grupę przechwytywania.Quantifiers can match multiple occurrences of a pattern that is defined by a capturing group. W tym przypadku Value i Length właściwości Group obiekt zawiera informacje tylko o ostatni podciąg przechwycony.In this case, the Value and Length properties of a Group object contain information only about the last captured substring. Na przykład poniższe wyrażenie regularne dopasowuje jednym zdaniu, która kończy się kropką.For example, the following regular expression matches a single sentence that ends in a period. Używa dwóch konstrukcje grupujące: Pierwszy przechwytuje poszczególne wyrazy wraz z biały znak; drugi przechwytuje poszczególne wyrazy.It uses two grouping constructs: The first captures individual words along with a white-space character; the second captures individual words. Dane wyjściowe z przykładu pokazują, mimo że wyrażenie regularne zakończy się pomyślnie w przechwytywaniu całe zdanie, druga grupa przechwytywania przechwytuje tylko ostatni wyraz.As the output from the example shows, although the regular expression succeeds in capturing an entire sentence, the second capturing group captures only the last word.

    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
    

Powrót do początkuBack to top

Kolekcja przechwytywaniaThe Capture Collection

Group Obiektu zawiera informacje dotyczące tylko ostatni przechwytywania.The Group object contains information only about the last capture. Jednak cały zestaw przechwytywań przez grupę przechwytywania jest nadal dostępne z poziomu CaptureCollection obiektu, który jest zwracany przez Group.Captures właściwości.However, the entire set of captures made by a capturing group is still available from the CaptureCollection object that is returned by the Group.Captures property. Każdy element członkowski kolekcji jest Capture obiekt, który reprezentuje przechwytywania wprowadzone przez grupę przechwytywania, w kolejności, w którym zostały przechwycone (i w związku z tym, w kolejności, w którym zostały dopasowane przechwyconych ciągi od lewej do prawej w ciągu wejściowym).Each member of the collection is a Capture object that represents a capture made by that capturing group, in the order in which they were captured (and, therefore, in the order in which the captured strings were matched from left to right in the input string). Możesz pobrać poszczególne Capture obiektów z kolekcji w jeden z dwóch sposobów:You can retrieve individual Capture objects from the collection in either of two ways:

  • Według iteracji w kolekcji przy użyciu konstrukcji, takich jak foreach (w języku C#) lub For Each (w języku Visual Basic).By iterating through the collection using a construct such as foreach (in C#) or For Each (in Visual Basic).

  • Za pomocą CaptureCollection.Item[Int32] właściwość służąca do pobierania z określonym obiektem według indeksu.By using the CaptureCollection.Item[Int32] property to retrieve a specific object by index. Item[Int32] Właściwość CaptureCollection indeksatora (w języku C#) lub domyślnej właściwości (w języku Visual Basic) obiektu.The Item[Int32] property is the CaptureCollection object's default property (in Visual Basic) or indexer (in C#).

Jeśli do grupy przechwytywania, nie jest stosowany kwantyfikator CaptureCollection obiekt zawiera pojedynczy Capture obiektu, który ma znaczenie nieco, ponieważ zawiera informacje o tym samym dopasowaniem jako jego Group obiektu.If a quantifier is not applied to a capturing group, the CaptureCollection object contains a single Capture object that is of little interest, because it provides information about the same match as its Group object. Jeśli do grupy przechwytywania, jest stosowany kwantyfikator CaptureCollection obiekt zawiera wszystkie przechwytywań przez grupę przechwytywania, a ostatni element członkowski kolekcji reprezentuje sam przechwytywania jako Group obiektu.If a quantifier is applied to a capturing group, the CaptureCollection object contains all captures made by the capturing group, and the last member of the collection represents the same capture as the Group object.

Na przykład, jeśli używasz wzorzec wyrażenia regularnego ((a(b))c)+ (gdzie + kwantyfikator Określa jedno lub więcej dopasowań) do przechwytywania jest zgodny z ciągiem "abcabcabc" CaptureCollection obiekt dla każdego Group obiekt zawiera trzy elementy członkowskie.For example, if you use the regular expression pattern ((a(b))c)+ (where the + quantifier specifies one or more matches) to capture matches from the string "abcabcabc", the CaptureCollection object for each Group object contains three members.

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 dosplays 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 regularnego (Abc)+ można znaleźć co najmniej jeden przebieg kolejnych ciągu "Abc" w ciągu "XYZAbcAbcAbcXYZAbcAb".The following example uses the regular expression (Abc)+ to find one or more consecutive runs of the string "Abc" in the string "XYZAbcAbcAbcXYZAbcAb". W przykładzie pokazano użycie Group.Captures właściwości, aby zwrócić wiele grup przechwycone podciągi.The example illustrates the use of the Group.Captures property to return multiple groups of captured substrings.

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

   // Look for groupings of "Abc".
   Regex 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  

Powrót do początkuBack to top

Poszczególne przechwytywaniaThe Individual Capture

Capture Klasa zawiera wyniki przechwycone Podwyrażenie jednego.The Capture class contains the results from a single subexpression capture. Capture.Value Właściwość zawiera dopasowany tekst i Capture.Index właściwość wskazuje liczona od zera pozycja w ciągu wejściowym, od której rozpoczyna się podciągiem.The Capture.Value property contains the matched text, and the Capture.Index property indicates the zero-based position in the input string at which the matched substring begins.

Poniższy przykład analizuje ciągu wejściowym, aby temperatura wybranych miastach.The following example parses an input string for the temperature of selected cities. Przecinek (",") jest używany do oddzielania miejscowość i jego temperatury i średnikiem (";") jest używany do oddzielania danych każdego miasta.A comma (",") is used to separate a city and its temperature, and a semicolon (";") is used to separate each city's data. Cały ciąg wejściowy reprezentuje pojedyncze dopasowanie.The entire input string represents a single match. We wzorcu wyrażenia regularnego ((\w+(\s\w+)*),(\d+);)+, używany do analizowania, nazwę miasta jest przypisany do drugiej grupy przechwytywania i temperatura jest przypisany do czwartej grupa przechwytywania.In the regular expression pattern ((\w+(\s\w+)*),(\d+);)+, which is used to parse the string, the city name is assigned to the second capturing group, and the temperature is assigned to the fourth capturing group.

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 zdefiniowane, jak pokazano w poniższej tabeli.The regular expression is defined as shown in the following table.

WzorzecPattern OpisDescription
\w+ Dopasowuje co najmniej jeden znak słowa.Match one or more word characters.
(\s\w+)* Dopasowuje zero lub więcej wystąpień znak odstępu, w którym następuje co najmniej jeden znak słowa.Match zero or more occurrences of a white-space character followed by one or more word characters. Ten wzorzec pasuje do nazwy miast wielu słów.This pattern matches multi-word city names. Jest to trzecia grupa przechwytywania.This is the third capturing group.
(\w+(\s\w+)*) Dopasowuje co najmniej jeden znak słowa, następuje zero lub więcej wystąpień znaku odstępu i co najmniej jeden znak słowa.Match one or more word characters followed by zero or more occurrences of a white-space character and one or more word characters. Jest to druga grupa przechwytywania.This is the second capturing group.
, Odpowiada wartości przecinkami.Match a comma.
(\d+) Dopasowuje jeden lub więcej cyfr.Match one or more digits. Jest to czwarty grupa przechwytywania.This is the fourth capturing group.
; Dopasowuje średnikiem.Match a semicolon.
((\w+(\s\w+)*),(\d+);)+ Pasuje do wzorca programu word, następuje dodatkowych słów, następuje przecinek, co najmniej jedna cyfra i średnikiem, jeden lub więcej razy.Match the pattern of a word followed by any additional words followed by a comma, one or more digits, and a semicolon, one or more times. Jest to pierwsza grupa przechwytywania.This is the first capturing group.

Zobacz takżeSee also