Regex.GetGroupNumbers Méthode

Définition

Retourne un tableau des numéros de groupes de captures qui correspondent aux noms de groupes d'un tableau.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()

Retours

Int32[]

Tableau d'entiers de numéros de groupes.An integer array of group numbers.

Exemples

L’exemple suivant définit une expression régulière, \b((?<word>\w+)\s*)+(?<end>[.?!]), qui correspond à une phrase.The following example defines a regular expression, \b((?<word>\w+)\s*)+(?<end>[.?!]), that matches a sentence. L’expression régulière comprend trois groupes de capture : un groupe sans nom qui capture un mot individuel avec un espace qui peut le suivre ; un groupe nommé word qui capture les mots individuels dans la phrase ; et un groupe nommé end qui capture la ponctuation qui termine la phrase.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. L’exemple appelle la méthode GetGroupNumbers pour récupérer les nombres de tous les groupes de capture, puis affiche leur chaîne capturée.The example calls the GetGroupNumbers method to get the numbers of all capturing groups, and then displays their captured string. En outre, la méthode GroupNameFromNumber est utilisée pour indiquer si un groupe numéroté particulier correspond à un groupe nommé.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): '.'

Le modèle d’expression régulière est interprété comme indiqué dans le tableau suivant.The regular expression pattern is interpreted as shown in the following table.

MotifPattern DescriptionDescription
\b Commencer la correspondance à la limite d'un mot.Begin the match at a word boundary.
(?<word>\w+) Faire correspondre un ou plusieurs caractères alphabétiques et assigner les chaînes mises en correspondance à un groupe nommé word.Match one or more word characters and assign the matched strings to a group named word.
\s* Correspond à zéro, un ou plusieurs espaces blancs.Match zero or more white-space characters.
((?<word>\w+)\s*) Assignez le word groupe capturé suivi de tout espace blanc capturé dans le premier groupe capturé.Assign the word captured group followed by any captured white-space characters to the first captured group.
((?<word>\w+)\s*)+ Faire correspondre le modèle d’un ou plusieurs caractères alphabétiques suivis de tout espace blanc une ou plusieurs fois.Match the pattern of one or more word characters followed by any white-space characters one or more times.
(?<end>[.?!]) Mettre en correspondance un point, un point d'interrogation ou un point d'exclamation.Match a period, question mark, or exclamation point. Assignez le caractère correspondant au groupe de capture end.Assign the matched character to the end capturing group.

Remarques

Les groupes de capture nommés et sans nom sont accessibles par nombre.Both unnamed and named capturing groups can be accessed by number. Les groupes sans nom sont numérotés de gauche à droite à partir de 1.Unnamed groups are numbered from left to right starting with 1. (Le groupe de capture dans l’index 0 (zéro) représente la correspondance dans son ensemble.) Les groupes nommés sont ensuite numérotés de gauche à droite en commençant par un nombre supérieur ou égal au nombre de groupes de capture sans nom.(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.

Le fait de référencer un groupe par son numéro au lieu du nom de chaîne peut fournir un accès plus rapide.Referencing a group by its number instead of by string name can provide faster access.

S’applique à

Voir aussi