Group.Captures Propiedad

Definición

Obtiene una colección de todas las capturas que coinciden con el grupo de captura, en orden empezando por el más interno de la izquierda (o por el más interno de la derecha si se modifica con la opción 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 colección puede tener cero o más elementos.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

Valor de propiedad

CaptureCollection

Colección de subcadenas que coinciden por el grupo.The collection of substrings matched by the group.

Comentarios

Si no se aplica un cuantificador a un grupo de captura, la colección devuelta por la Captures propiedad contiene un solo Capture objeto que proporciona información sobre la misma subcadena que el Group objeto.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. Esto se muestra en el ejemplo siguiente.This is illustrated in the following example. Define una expresión regular, \b(\w+)\b , que extrae una sola palabra de una oración.It defines a regular expression, \b(\w+)\b, that extracts a single word from a sentence. El Group objeto captura la palabra "this" y el único objeto de CaptureCollection contiene información sobre la misma captura.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

La utilidad real de la Captures propiedad tiene lugar cuando se aplica un cuantificador a un grupo de captura para que el grupo Capture varias subcadenas en una expresión regular única.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. En este caso, el Group objeto contiene información sobre la última subcadena capturada, mientras que la Captures propiedad contiene información sobre todas las subcadenas capturadas por el grupo.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. En el ejemplo siguiente, la expresión regular \b(\w+\s*)+\. coincide con una oración completa que termina en un punto.In the following example, the regular expression \b(\w+\s*)+\. matches an entire sentence that ends in a period. El grupo (\w+\s*)+ captura las palabras individuales de la colección.The group (\w+\s*)+ captures the individual words in the collection. Dado que la Group colección contiene información solo sobre la última subcadena capturada, captura la última palabra de la frase "oración".Because the Group collection contains information only about the last captured substring, it captures the last word in the sentence, "sentence". Sin embargo, cada palabra capturada por el grupo está disponible en la colección devuelta por la Captures propiedad.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

Se aplica a

Consulte también