Regex.GetGroupNumbers Método

Definición

Devuelve una matriz de números de grupo de captura que corresponde a los nombres de grupo en una matriz.Returns an array of capturing group numbers that correspond to group names in an array.

public:
 cli::array <int> ^ GetGroupNumbers();
public int[] GetGroupNumbers ();
member this.GetGroupNumbers : unit -> int[]
Public Function GetGroupNumbers () As Integer()

Devoluciones

Int32[]

Matriz de enteros de números de grupo.An integer array of group numbers.

Ejemplos

En el ejemplo siguiente se define una expresión regular, \b((?<word>\w+)\s*)+(?<end>[.?!]), que coincide con una oración.The following example defines a regular expression, \b((?<word>\w+)\s*)+(?<end>[.?!]), that matches a sentence. La expresión regular incluye tres grupos de captura: un grupo sin nombre que captura una palabra individual junto con un carácter de espacio que puede seguir. grupo denominado word que captura las palabras individuales de la oración; y un grupo denominado end que captura la puntuación que finaliza la oración.The regular expression includes three capturing groups: an unnamed group that captures an individual word along with a space character that may follow it; a group named word that captures the individual words in the sentence; and a group named end that captures the punctuation that ends the sentence. En el ejemplo se llama al método GetGroupNumbers para obtener los números de todos los grupos de captura y, a continuación, se muestra la cadena capturada.The example calls the GetGroupNumbers method to get the numbers of all capturing groups, and then displays their captured string. Además, el método GroupNameFromNumber se usa para indicar si un grupo numerado determinado corresponde a un grupo con nombre.In addition, the GroupNameFromNumber method is used to indicate whether a particular numbered group corresponds to a named group.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b((?<word>\w+)\s*)+(?<end>[.?!])";
      string input = "This is a sentence. This is a second sentence.";
      
      Regex rgx = new Regex(pattern);
      int[] groupNumbers = rgx.GetGroupNumbers();
      Match m = rgx.Match(input);
      if (m.Success) {
         Console.WriteLine("Match: {0}", m.Value);
         foreach (var groupNumber in groupNumbers) {
            string name = rgx.GroupNameFromNumber(groupNumber);
            int number;
            Console.WriteLine("   Group {0}{1}: '{2}'", 
                              groupNumber, 
                              ! string.IsNullOrEmpty(name) & 
                              ! Int32.TryParse(name, out number) ?
                                 " (" + name + ")" : String.Empty, 
                              m.Groups[groupNumber].Value);
         }
      } 
   }
}
// The example displays the following output:
//       Match: This is a sentence.
//          Group 0: 'This is a sentence.'
//          Group 1: 'sentence'
//          Group 2 (word): 'sentence'
//          Group 3 (end): '.'
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String= "\b((?<word>\w+)\s*)+(?<end>[.?!])"
      Dim input As String = "This is a sentence. This is a second sentence."
      
      Dim rgx As New Regex(pattern)
      Dim groupNumbers() As Integer = rgx.GetGroupNumbers()
      Dim m As Match = rgx.Match(input)
      If m.Success Then
         Console.WriteLine("Match: {0}", m.Value)
         For Each groupNumber In groupNumbers
            Dim name As String = rgx.GroupNameFromNumber(groupNumber)
            Dim number As Integer
            Console.WriteLine("   Group {0}{1}: '{2}'", 
                              groupNumber, 
                              If(Not String.IsNullOrEmpty(name) And 
                              Not Int32.TryParse(name, number),
                                 " (" + name + ")", String.Empty), 
                              m.Groups(groupNumber).Value)
         Next
      End If 
   End Sub
End Module
' The example displays the following output:
'       Match: This is a sentence.
'          Group 0: 'This is a sentence.'
'          Group 1: 'sentence'
'          Group 2 (word): 'sentence'
'          Group 3 (end): '.'

El patrón de la expresión regular se interpreta como se muestra en la tabla siguiente.The regular expression pattern is interpreted as shown in the following table.

PatrónPattern DescripciónDescription
\b Iniciar la búsqueda de coincidencias en un límite de palabras.Begin the match at a word boundary.
(?<word>\w+) Coincide con uno o varios caracteres de palabra y asigna las cadenas coincidentes a un grupo denominado word.Match one or more word characters and assign the matched strings to a group named word.
\s* Busca coincidencias con cero o más caracteres de espacio en blanco.Match zero or more white-space characters.
((?<word>\w+)\s*) Asigne el word grupo capturado seguido de cualquier carácter de espacio en blanco capturado al primer grupo capturado.Assign the word captured group followed by any captured white-space characters to the first captured group.
((?<word>\w+)\s*)+ Buscar coincidencias con el patrón de uno o varios caracteres de palabra seguidos de cualquier carácter de espacio en blanco una o varias veces.Match the pattern of one or more word characters followed by any white-space characters one or more times.
(?<end>[.?!]) Buscar coincidencias con un punto, un signo de interrogación o un signo de exclamación.Match a period, question mark, or exclamation point. Asigne el carácter coincidente al grupo de captura end.Assign the matched character to the end capturing group.

Comentarios

Se puede tener acceso a los grupos de captura sin nombre y con nombre por número.Both unnamed and named capturing groups can be accessed by number. Los grupos sin nombre se numeran de izquierda a derecha a partir de 1.Unnamed groups are numbered from left to right starting with 1. (El grupo de captura en el índice 0 (cero) representa la coincidencia como un todo). Los grupos con nombre se numeran de izquierda a derecha empezando por un número que es mayor que el número de grupos de captura sin nombre.(The capturing group in index 0 (zero) represents the match as a whole.) Named groups are then numbered from left to right starting with a number that is one greater than the number of unnamed capturing groups.

La referencia a un grupo por su número en lugar de por el nombre de la cadena puede proporcionar un acceso más rápido.Referencing a group by its number instead of by string name can provide faster access.

Se aplica a

Consulte también: