Group.Captures Propriété

Définition

Obtient une collection de toutes les captures correspondant au groupe de capture, dans l'ordre du plus profond et du plus à gauche (ou dans l'ordre du plus profond et du plus à droite, si l'expression régulière est modifiée par l'option RightToLeft).Gets a collection of all the captures matched by the capturing group, in innermost-leftmost-first order (or innermost-rightmost-first order if the regular expression is modified with the RightToLeft option). La collection peut contenir entre zéro et plusieurs éléments.The collection may have zero or more items.

public:
 property System::Text::RegularExpressions::CaptureCollection ^ Captures { System::Text::RegularExpressions::CaptureCollection ^ get(); };
public System.Text.RegularExpressions.CaptureCollection Captures { get; }
member this.Captures : System.Text.RegularExpressions.CaptureCollection
Public ReadOnly Property Captures As CaptureCollection

Valeur de propriété

Collection de sous-chaînes correspondant au groupe.The collection of substrings matched by the group.

Remarques

Si aucun quantificateur n’est appliqué à un groupe de capture, la collection retournée par Captures la propriété contient un Capture objet unique qui fournit des informations sur la même sous- Group chaîne que l’objet.If a quantifier is not applied to a capturing group, the collection returned by the Captures property contains a single Capture object that provides information about the same substring as the Group object. L'exemple suivant illustre cette opération.This is illustrated in the following example. Il définit une expression régulière, \b(\w+)\b, qui extrait un mot unique à partir d’une phrase.It defines a regular expression, \b(\w+)\b, that extracts a single word from a sentence. L' Group objet capture le mot «This» et l’objet unique dans le CaptureCollection contient des informations sur la même capture.The Group object captures the word "This", and the single object in the CaptureCollection contains information about the same capture.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\w+)\b";
      string input = "This is one sentence.";
      Match match = Regex.Match(input, pattern);
      if (match.Success) {
         Console.WriteLine("Matched text: {0}", match.Value);
         for (int ctr = 1; ctr <= match.Groups.Count - 1; ctr++) {
            Console.WriteLine("   Group {0}:  {1}", ctr, match.Groups[ctr].Value);
            int captureCtr = 0;
            foreach (Capture capture in match.Groups[ctr].Captures) {
               Console.WriteLine("      Capture {0}: {1}", 
                                 captureCtr, capture.Value);
               captureCtr += 1;                  
            }
         }
      }   
   }
}
// The example displays the following output:
//       Matched text: This
//          Group 1:  This
//             Capture 0: This
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(\w+)\b"
      Dim input As String = "This is one sentence."
      Dim match As Match = Regex.Match(input, pattern)
      If match.Success Then
         Console.WriteLine("Matched text: {0}", match.Value)
         For ctr As Integer = 1 To match.Groups.Count - 1
            Console.WriteLine("   Group {0}:  {1}", ctr, match.Groups(ctr).Value)
            Dim captureCtr As Integer = 0
            For Each capture As Capture In match.Groups(ctr).Captures
               Console.WriteLine("      Capture {0}: {1}", _
                                 captureCtr, capture.Value)
               captureCtr += 1                  
            Next
         Next
      End If   
   End Sub
End Module
' The example displays the following output:
'       Matched text: This
'          Group 1:  This
'             Capture 0: This

L’utilitaire réel de la Captures propriété se produit lorsqu’un quantificateur est appliqué à un groupe de capture afin que le groupe capture plusieurs sous-chaînes dans une même expression régulière.The real utility of the Captures property occurs when a quantifier is applied to a capturing group so that the group captures multiple substrings in a single regular expression. Dans ce cas, l' Group objet contient des informations sur la dernière sous-chaîne capturée Captures , tandis que la propriété contient des informations sur toutes les sous-chaînes capturées par le groupe.In this case, the Group object contains information about the last captured substring, whereas the Captures property contains information about all the substrings captured by the group. Dans l’exemple suivant, l’expression \b(\w+\s*)+\. régulière correspond à une phrase entière qui se termine par un point.In the following example, the regular expression \b(\w+\s*)+\. matches an entire sentence that ends in a period. Le groupe (\w+\s*)+ capture les mots individuels dans la collection.The group (\w+\s*)+ captures the individual words in the collection. Étant donné Group que la collection contient des informations uniquement sur la dernière sous-chaîne capturée, elle capture le dernier mot de la phrase «phrase».Because the Group collection contains information only about the last captured substring, it captures the last word in the sentence, "sentence". Toutefois, chaque mot capturé par le groupe est disponible à partir de la collection retournée par la Captures propriété.However, each word captured by the group is available from the collection returned by the Captures property.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is a sentence. This is another sentence.";
      string pattern = @"\b(\w+\s*)+\.";
      Match match = Regex.Match(input, pattern);
      if (match.Success) {
         Console.WriteLine("Matched text: {0}", match.Value);
         for (int ctr = 1; ctr < match.Groups.Count; ctr++) {
            Console.WriteLine("   Group {0}:  {1}", ctr, match.Groups[ctr].Value);
            int captureCtr = 0;
            foreach (Capture capture in match.Groups[ctr].Captures) {
               Console.WriteLine("      Capture {0}: {1}", 
                                 captureCtr, capture.Value);
               captureCtr++; 
            }
         }
      }   
   }
}
// The example displays the following output:
//       Matched text: This is a sentence.
//          Group 1:  sentence
//             Capture 0: This
//             Capture 1: is
//             Capture 2: a
//             Capture 3: sentence
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is a sentence. This is another sentence."
      Dim pattern As String = "\b(\w+\s*)+\."
      Dim match As Match = Regex.Match(input, pattern)
      If match.Success Then
         Console.WriteLine("Matched text: {0}", match.Value)
         For ctr As Integer = 1 To match.Groups.Count - 1
            Console.WriteLine("   Group {0}:  {1}", ctr, match.Groups(ctr).Value)
            Dim captureCtr As Integer = 0
            For Each capture As Capture In match.Groups(ctr).Captures
               Console.WriteLine("      Capture {0}: {1}", _
                                 captureCtr, capture.Value)
               captureCtr += 1                  
            Next
         Next
      End If   
   End Sub
End Module
' The example displays the following output:
'       Matched text: This is a sentence.
'          Group 1:  sentence
'             Capture 0: This
'             Capture 1: is
'             Capture 2: a
'             Capture 3: sentence

S’applique à

Voir aussi