Compartir vía

Regex.GetGroupNames Método

  • Referencia

Definición

Espacio de nombres:
System.Text.RegularExpressions
Ensamblado:
System.Text.RegularExpressions.dll
Ensamblado:
System.dll
Ensamblado:
netstandard.dll

Devuelve una matriz de nombres de grupo de captura para la expresión regular.

public:
 cli::array <System::String ^> ^ GetGroupNames();
public string[] GetGroupNames ();
member this.GetGroupNames : unit -> string[]
Public Function GetGroupNames () As String()

Devoluciones

String[]

Matriz de cadenas de nombres de grupo.

Ejemplos

En el ejemplo siguiente se define un método de uso ShowMatches general que muestra los nombres de los grupos de expresiones regulares y su texto coincidente.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(?<FirstWord>\w+)\s?((\w+)\s)*(?<LastWord>\w+)?(?<Punctuation>\p{Po})";
      string input = "The cow jumped over the moon.";
      Regex rgx = new Regex(pattern);
      Match match = rgx.Match(input);
      if (match.Success)
         ShowMatches(rgx, match);
   }

   private static void ShowMatches(Regex r, Match m)
   {
      string[] names = r.GetGroupNames();
      Console.WriteLine("Named Groups:");
      foreach (var name in names) {
         Group grp = m.Groups[name];
         Console.WriteLine("   {0}: '{1}'", name, grp.Value);
      }
   }
}
// The example displays the following output:
//       Named Groups:
//          0: 'The cow jumped over the moon.'
//          1: 'the '
//          2: 'the'
//          FirstWord: 'The'
//          LastWord: 'moon'
//          Punctuation: '.'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(?<FirstWord>\w+)\s?((\w+)\s)*(?<LastWord>\w+)?(?<Punctuation>\p{Po})"
      Dim input As String = "The cow jumped over the moon."
      Dim rgx As New Regex(pattern)
      Dim match As Match = rgx.Match(input)
      If match.Success Then ShowMatches(rgx, match)
   End Sub
   
   Private Sub ShowMatches(r As Regex, m As Match)
      Dim names() As String = r.GetGroupNames()
      Console.WriteLine("Named Groups:")
      For Each name In names
         Dim grp As Group = m.Groups.Item(name)
         Console.WriteLine("   {0}: '{1}'", name, grp.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       Named Groups:
'          0: 'The cow jumped over the moon.'
'          1: 'the '
'          2: 'the'
'          FirstWord: 'The'
'          LastWord: 'moon'
'          Punctuation: '.'

En este caso, el patrón \b(?<FirstWord>\w+)\s?((\w+)\s)*(?<LastWord>\w+)?(?<Punctuation>\p{Po}) de expresión regular está pensado para analizar una frase simple e identificar su primera palabra, última palabra y signo de puntuación final. En la tabla siguiente se muestra cómo se interpreta el patrón de expresión regular:

Patrón Descripción
\b Iniciar la búsqueda de coincidencias en un límite de palabras.
(?<FirstWord>\w+) Buscar coincidencias con uno o más caracteres alfabéticos. Este es el FirstWord grupo con nombre.
¿\s? Busca una coincidencia con cero o un carácter de espacio en blanco.
(\w+) Buscar coincidencias con uno o más caracteres alfabéticos. Este es el segundo grupo de captura.
\s Coincide con un carácter de espacio en blanco.
((\w+)\s)* Coincide con cero o más repeticiones de uno o más caracteres de palabra seguidos de un espacio en blanco. Este es el primer grupo de captura.
(?<LastWord> \w+)? Coincide con cero o una repetición de uno o varios caracteres de palabra. Este es el LastWord grupo con nombre.
(?<Punctuation> \p{Po}) Coincide con un carácter cuya categoría Unicode es Puntuación, Otra. Este es el Punctuation grupo con nombre.

Comentarios

La colección de nombres de grupo contiene el conjunto de cadenas usadas para asignar nombres a grupos de captura en la expresión. Incluso si la captura de grupos no se denomina explícitamente, se les asignan automáticamente nombres numéricos ("0", "1", "2", "3", etc.). El grupo con nombre "0" representa todo el texto coincidente con el patrón de expresión regular. Los grupos numerados preceden explícitamente a los grupos con nombre de la colección y los grupos con nombre aparecen en el orden en que se definen en el patrón de expresión regular.

Puede usar la Length propiedad en la matriz devuelta por este método para determinar el número de grupos de una expresión regular.

Se aplica a

Consulte también