Match.Groups Propriété

Définition

Obtient une collection de groupes correspondant à l'expression régulière.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

Valeur de propriété

Groupes de caractères correspondant au modèle.The character groups matched by the pattern.

Exemples

L’exemple suivant tente de faire correspondre un modèle d’expression régulière à un exemple de chaîne.The following example attempts to match a regular expression pattern against a sample string. L’exemple utilise la propriété Groups pour stocker des informations qui sont récupérées par la correspondance pour l’affichage sur la console.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

Remarques

Un modèle d’expression régulière peut inclure des sous-expressions, qui sont définies en mettant une partie du modèle d’expression régulière entre parenthèses.A regular expression pattern can include subexpressions, which are defined by enclosing a portion of the regular expression pattern in parentheses. Chaque sous-expression de ce type est un groupe.Every such subexpression forms a group. La propriété Groups fournit l’accès aux informations sur ces correspondances de sous-expression.The Groups property provides access to information about those subexpression matches. Par exemple, le modèle d’expression régulière (\d{3})-(\d{3}-\d{4}), qui correspond aux numéros de téléphone de l’Amérique du Nord, a deux sous-expressions.For example, the regular expression pattern (\d{3})-(\d{3}-\d{4}), which matches North American telephone numbers, has two subexpressions. Le premier est constitué de l’indicatif de zone, qui compose les trois premiers chiffres du numéro de téléphone.The first consists of the area code, which composes the first three digits of the telephone number. Ce groupe est capturé par la première partie de l’expression régulière, (\d{3}). Le deuxième est constitué du numéro de téléphone individuel, qui compose les sept derniers chiffres du numéro de téléphone.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. Ce groupe est capturé par la deuxième partie de l’expression régulière, (\d{3}-\d{4}).This group is captured by the second portion of the regular expression, (\d{3}-\d{4}). Ces deux groupes peuvent ensuite être récupérés à partir de l’objet GroupCollection retourné par la propriété Groups, comme le montre l’exemple suivant.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

L’objet GroupCollection retourné par la propriété Match.Groups est un objet de collection de base zéro qui a toujours au moins un membre.The GroupCollection object returned by the Match.Groups property is a zero-based collection object that always has at least one member. Si le moteur d’expression régulière ne peut pas trouver de correspondance dans une chaîne d’entrée particulière, la propriété Group.Success de l’objet Group unique dans la collection (l’objet à l’index 0) est définie sur false et la propriété Value de l’objet Group est définie sur String.Empty.If 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. Si le moteur des expressions régulières peut trouver une correspondance, le premier élément de l’objet GroupCollection (l’élément à l’index 0) retourné par la propriété Groups contient une chaîne qui correspond au modèle d’expression régulière entier.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. Chaque élément suivant, de l’index un vers le haut, représente un groupe capturé, si l’expression régulière comprend des groupes de capture.Each subsequent element, from index one upward, represents a captured group, if the regular expression includes capturing groups. Pour plus d’informations, consultez la section « constructions de regroupement et objets d’expression régulière » de l’article sur les constructions de regroupement .For more information, see the "Grouping Constructs and Regular Expression Objects" section of the Grouping Constructs article.

S’applique à