Compartir a través de


Group Clase

Definición

Representa los resultados de un único grupo de captura.

public ref class Group : System::Text::RegularExpressions::Capture
public class Group : System.Text.RegularExpressions.Capture
[System.Serializable]
public class Group : System.Text.RegularExpressions.Capture
type Group = class
    inherit Capture
[<System.Serializable>]
type Group = class
    inherit Capture
Public Class Group
Inherits Capture
Herencia
Group
Derivado
Atributos

Comentarios

Un grupo de captura puede capturar cero, una o más cadenas en una sola coincidencia debido a cuantificadores. (Para obtener más información, vea Cuantificadores). Todas las subcadenas coincidentes con un único grupo de captura están disponibles en la Group.Captures propiedad . Se puede acceder directamente a la información sobre la última subcadena capturada desde las Value propiedades y Index . (Es decir, la Group instancia es equivalente al último elemento de la colección devuelta por la Captures propiedad , que refleja la última captura realizada por el grupo de captura).

Un ejemplo ayuda a aclarar esta relación entre un Group objeto y el System.Text.RegularExpressions.CaptureCollection devuelto por la Captures propiedad . El patrón (\b(\w+?)[,:;]?\s?)+[?.!] de expresión regular coincide con oraciones completas. La expresión regular se define como se muestra en la tabla siguiente.

Modelo Descripción
\b Iniciar la búsqueda de coincidencias en un límite de palabras.
(\w+?) Coincide con uno o más caracteres de palabra, pero con el menor número de caracteres posible. Este es el segundo grupo de captura (interno). (El primer grupo de captura incluye el \b elemento language).
[,:;]? Coincide con cero o una aparición de una coma, dos puntos o punto y coma.
\s? Coincide con cero o una aparición de un carácter de espacio en blanco.
(\b(\w+?)[,:;]?\s?)+ Coincide con el patrón que consta de un límite de palabra, uno o varios caracteres de palabra, un símbolo de puntuación y un carácter de espacio en blanco una o varias veces. Este es el primer grupo de captura.
[?.!] Coincide con cualquier aparición de un punto, signo de interrogación o signo de exclamación.

En este patrón de expresión regular, el subpattern (\w+?) está diseñado para coincidir con varias palabras dentro de una oración. Sin embargo, el valor del Group objeto representa solo la última coincidencia que (\w+?) captura, mientras que la Captures propiedad devuelve un CaptureCollection que representa todo el texto capturado. Como se muestra en la salida, el CaptureCollection para el segundo grupo de captura contiene cuatro objetos. La última de estas corresponde al Group objeto .

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\b(\w+?)[,:;]?\s?)+[?.!]";
      string input = "This is one sentence. This is a second sentence.";

      Match match = Regex.Match(input, pattern);
      Console.WriteLine("Match: " + match.Value);
      int groupCtr = 0;
      foreach (Group group in match.Groups)
      {
         groupCtr++;
         Console.WriteLine("   Group {0}: '{1}'", groupCtr, group.Value);
         int captureCtr = 0;
         foreach (Capture capture in group.Captures)
         {
            captureCtr++;
            Console.WriteLine("      Capture {0}: '{1}'", captureCtr, capture.Value);
         }
      }   
   }
}
// The example displays the following output:
//       Match: This is one sentence.
//          Group 1: 'This is one sentence.'
//             Capture 1: 'This is one sentence.'
//          Group 2: 'sentence'
//             Capture 1: 'This '
//             Capture 2: 'is '
//             Capture 3: 'one '
//             Capture 4: 'sentence'
//          Group 3: 'sentence'
//             Capture 1: 'This'
//             Capture 2: 'is'
//             Capture 3: 'one'
//             Capture 4: 'sentence'
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\b(\w+?)[,:;]?\s?)+[?.!]"
      Dim input As String = "This is one sentence. This is a second sentence."

      Dim match As Match = Regex.Match(input, pattern)
      Console.WriteLine("Match: " + match.Value)
      Dim groupCtr As Integer = 0
      For Each group As Group In match.Groups
         groupCtr += 1
         Console.WriteLine("   Group {0}: '{1}'", groupCtr, group.Value)
         Dim captureCtr As Integer = 0
         For Each capture As Capture In group.Captures
            captureCtr += 1
            Console.WriteLine("      Capture {0}: '{1}'", captureCtr, capture.Value)
         Next
      Next   
   End Sub
End Module
' The example displays the following output:
'       Match: This is one sentence.
'          Group 1: 'This is one sentence.'
'             Capture 1: 'This is one sentence.'
'          Group 2: 'sentence'
'             Capture 1: 'This '
'             Capture 2: 'is '
'             Capture 3: 'one '
'             Capture 4: 'sentence'
'          Group 3: 'sentence'
'             Capture 1: 'This'
'             Capture 2: 'is'
'             Capture 3: 'one'
'             Capture 4: 'sentence'

Propiedades

Captures

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). La colección puede tener cero o más elementos.

Index

Posición en la cadena original donde se encuentra el primer carácter de la subcadena capturada.

(Heredado de Capture)
Length

Obtiene la longitud de la subcadena capturada.

(Heredado de Capture)
Name

Devuelve el nombre del grupo de captura que la instancia actual representa.

Success

Obtiene un valor que indica si la coincidencia ha tenido éxito.

Value

Obtiene la subcadena capturada desde la cadena de entrada.

(Heredado de Capture)
ValueSpan

Obtiene el intervalo capturado de la cadena de entrada.

(Heredado de Capture)

Métodos

Equals(Object)

Determina si el objeto especificado es igual que el objeto actual.

(Heredado de Object)
GetHashCode()

Sirve como la función hash predeterminada.

(Heredado de Object)
GetType()

Obtiene el Type de la instancia actual.

(Heredado de Object)
MemberwiseClone()

Crea una copia superficial del Object actual.

(Heredado de Object)
Synchronized(Group)

Devuelve un objeto Group equivalente al suministrado que puede compartirse con seguridad entre varios subprocesos.

ToString()

Recupera la subcadena capturada de la cadena de entrada llamando a la propiedad Value.

(Heredado de Capture)

Se aplica a