Match.Groups Match.Groups Match.Groups Match.Groups Property

定義

取得符合規則運算式的群組集合。Gets a collection of groups matched by the regular expression.

public:
 virtual property System::Text::RegularExpressions::GroupCollection ^ Groups { System::Text::RegularExpressions::GroupCollection ^ get(); };
public virtual System.Text.RegularExpressions.GroupCollection Groups { get; }
member this.Groups : System.Text.RegularExpressions.GroupCollection
Public Overridable ReadOnly Property Groups As GroupCollection

屬性值

符合模式的字元群組。The character groups matched by the pattern.

範例

下列範例會嘗試比對正則運算式模式與範例字串。The following example attempts to match a regular expression pattern against a sample string. 這個範例會使用Groups屬性來儲存比對顯示在主控台中的相符資訊。The example uses the Groups property to store information that is retrieved by the match for display to the console.

#using <System.dll>

using namespace System;
using namespace System::Text::RegularExpressions;
void main()
{
   
   String^ text = "One car red car blue car";
   String^ pat = "(\\w+)\\s+(car)";
   
   // Compile the regular expression.
   Regex^ r = gcnew Regex( pat,RegexOptions::IgnoreCase );
   
   // Match the regular expression pattern against a text string.
   Match^ m = r->Match(text);
   int matchCount = 0;
   while ( m->Success )
   {
      Console::WriteLine( "Match{0}", ++matchCount );
      for ( int i = 1; i <= 2; i++ )
      {
         Group^ g = m->Groups[ i ];
         Console::WriteLine( "Group{0}='{1}'", i, g );
         CaptureCollection^ cc = g->Captures;
         for ( int j = 0; j < cc->Count; j++ )
         {
            Capture^ c = cc[ j ];
            System::Console::WriteLine( "Capture{0}='{1}', Position={2}", j, c, c->Index );
         }
      }
      m = m->NextMatch();
   }
}  
// This example displays the following output:
//       Match1
//       Group1='One'
//       Capture0='One', Position=0
//       Group2='car'
//       Capture0='car', Position=4
//       Match2
//       Group1='red'
//       Capture0='red', Position=8
//       Group2='car'
//       Capture0='car', Position=12
//       Match3
//       Group1='blue'
//       Capture0='blue', Position=16
//       Group2='car'
//       Capture0='car', Position=21
using System;
using System.Text.RegularExpressions;

class Example 
{
   static void Main() 
   {
      string text = "One car red car blue car";
      string pat = @"(\w+)\s+(car)";

      // Instantiate the regular expression object.
      Regex r = new Regex(pat, RegexOptions.IgnoreCase);
      
      // Match the regular expression pattern against a text string.
      Match m = r.Match(text);
      int matchCount = 0;
      while (m.Success) 
      {
         Console.WriteLine("Match"+ (++matchCount));
         for (int i = 1; i <= 2; i++) 
         {
            Group g = m.Groups[i];
            Console.WriteLine("Group"+i+"='" + g + "'");
            CaptureCollection cc = g.Captures;
            for (int j = 0; j < cc.Count; j++) 
            {
               Capture c = cc[j];
               System.Console.WriteLine("Capture"+j+"='" + c + "', Position="+c.Index);
            }
         }
         m = m.NextMatch();
      }
   }
}
// This example displays the following output:
//       Match1
//       Group1='One'
//       Capture0='One', Position=0
//       Group2='car'
//       Capture0='car', Position=4
//       Match2
//       Group1='red'
//       Capture0='red', Position=8
//       Group2='car'
//       Capture0='car', Position=12
//       Match3
//       Group1='blue'
//       Capture0='blue', Position=16
//       Group2='car'
//       Capture0='car', Position=21
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim text As String = "One car red car blue car"
      Dim pattern As String = "(\w+)\s+(car)"

      ' Instantiate the regular expression object.
      Dim r As Regex = new Regex(pattern, RegexOptions.IgnoreCase)

      ' Match the regular expression pattern against a text string.
      Dim m As Match = r.Match(text)
      Dim matchcount as Integer = 0
      Do While m.Success
         matchCount += 1
         Console.WriteLine("Match" & (matchCount))
         Dim i As Integer
         For i = 1 to 2
            Dim g as Group = m.Groups(i)
            Console.WriteLine("Group" & i & "='" & g.ToString() & "'")
            Dim cc As CaptureCollection = g.Captures
            Dim j As Integer 
            For j = 0 to cc.Count - 1
              Dim c As Capture = cc(j)
               Console.WriteLine("Capture" & j & "='" & c.ToString() _
                  & "', Position=" & c.Index)
            Next 
         Next 
         m = m.NextMatch()
      Loop
   End Sub
End Module
' This example displays the following output:
'       Match1
'       Group1='One'
'       Capture0='One', Position=0
'       Group2='car'
'       Capture0='car', Position=4
'       Match2
'       Group1='red'
'       Capture0='red', Position=8
'       Group2='car'
'       Capture0='car', Position=12
'       Match3
'       Group1='blue'
'       Capture0='blue', Position=16
'       Group2='car'
'       Capture0='car', Position=21

備註

正則運算式模式可以包含子運算式, 其定義方式是以括弧括住正則運算式模式的一部分。A regular expression pattern can include subexpressions, which are defined by enclosing a portion of the regular expression pattern in parentheses. 每個這類子運算式都會形成一個群組。Every such subexpression forms a group. Groups屬性可讓您存取這些子運算式相符專案的相關資訊。The Groups property provides access to information about those subexpression matches. 例如, 符合北美電話號碼的(\d{3})-(\d{3}-\d{4})正則運算式模式有兩個子運算式。For example, the regular expression pattern (\d{3})-(\d{3}-\d{4}), which matches North American telephone numbers, has two subexpressions. 第一個是由區碼組成, 這會撰寫電話號碼的前三個數字。The first consists of the area code, which composes the first three digits of the telephone number. 這個群組是由正則運算式(\d{3})的第一個部分所捕捉。第二個是由個別電話號碼組成, 這會組合電話號碼的最後七個數字。This group is captured by the first portion of the regular expression, (\d{3}).The second consists of the individual telephone number, which composes the last seven digits of the telephone number. 這個群組是由正則運算式(\d{3}-\d{4})的第二個部分所捕捉。This group is captured by the second portion of the regular expression, (\d{3}-\d{4}). 然後, 您可以從GroupCollection Groups屬性傳回的物件中抓取這兩個群組, 如下列範例所示。These two groups can then be retrieved from the GroupCollection object that is returned by the Groups property, as the following example shows.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\d{3})-(\d{3}-\d{4})";
      string input = "212-555-6666 906-932-1111 415-222-3333 425-888-9999";
      MatchCollection matches = Regex.Matches(input, pattern);
      
      foreach (Match match in matches)
      {
         Console.WriteLine("Area Code:        {0}", match.Groups[1].Value);
         Console.WriteLine("Telephone number: {0}", match.Groups[2].Value);
         Console.WriteLine();
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       Area Code:        212
//       Telephone number: 555-6666
//       
//       Area Code:        906
//       Telephone number: 932-1111
//       
//       Area Code:        415
//       Telephone number: 222-3333
//       
//       Area Code:        425
//       Telephone number: 888-9999
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\d{3})-(\d{3}-\d{4})"
      Dim input As String = "212-555-6666 906-932-1111 415-222-3333 425-888-9999"
      Dim matches As MatchCollection = Regex.Matches(input, pattern)
      
      For Each match As Match In matches
         Console.WriteLine("Area Code:        {0}", match.Groups(1).Value)
         Console.WriteLine("Telephone number: {0}", match.Groups(2).Value)
         Console.WriteLine()
      Next
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'       Area Code:        212
'       Telephone number: 555-6666
'       
'       Area Code:        906
'       Telephone number: 932-1111
'       
'       Area Code:        415
'       Telephone number: 222-3333
'       
'       Area Code:        425
'       Telephone number: 888-9999

Match.Groups屬性GroupCollection所傳回的物件是一個以零為基底的集合物件, 其中一律至少有一個成員。The GroupCollection object returned by the Match.Groups property is a zero-based collection object that always has at least one member. 如果正則運算式引擎在特定輸入字串中找不到任何相符專案Group.Success , 則集合中Group單一物件 (位於索引0的物件) 的屬性Group會設定為false , 而物件的Value屬性設定為String.EmptyIf the regular expression engine cannot find any matches in a particular input string, the Group.Success property of the single Group object in the collection (the object at index 0) is set to false and the Group object's Value property is set to String.Empty. 如果正則運算式引擎可以找到相符專案, 則該GroupCollection物件的第一個專案 (位於索引0的元素) Groups會包含符合整個正則運算式模式的字串。If the regular expression engine can find a match, the first element of the GroupCollection object (the element at index 0) returned by the Groups property contains a string that matches the entire regular expression pattern. 如果正則運算式包含捕捉群組, 則每個後續的元素 (從索引一個向上) 代表一個已捕捉的群組。Each subsequent element, from index one upward, represents a captured group, if the regular expression includes capturing groups. 如需詳細資訊, 請參閱群組結構一文的「群組結構和正則運算式物件」一節。For more information, see the "Grouping Constructs and Regular Expression Objects" section of the Grouping Constructs article.

適用於