Regex.GetGroupNumbers Méthode

Référence

Définition

Espace de noms:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Retourne un tableau des numéros de groupes de captures qui correspondent aux noms de groupes d'un tableau.

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.

Exemples

L’exemple suivant définit une expression régulière, \b((?<word>\w+)\s*)+(?<end>[.?!])qui correspond à une phrase. L’expression régulière comprend trois groupes de capture : un groupe sans nom qui capture un mot individuel avec un caractère d’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 met fin à la phrase. L’exemple appelle la GetGroupNumbers méthode pour obtenir le nombre de tous les groupes de capture, puis affiche leur chaîne capturée. En outre, la GroupNameFromNumber méthode est utilisée pour indiquer si un groupe numéroté particulier correspond à un groupe nommé.

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.

Modèle	Description
`\b`	Commencer la correspondance à la limite d'un mot.
`(?<word>\w+)`	Mettre en correspondance un ou plusieurs caractères de mot et affecter les chaînes correspondantes à un groupe nommé `word`.
`\s*`	Correspond à zéro, un ou plusieurs espaces blancs.
`((?<word>\w+)\s*)`	Affectez le `word` groupe capturé suivi de tous les espaces blancs capturés au premier groupe capturé.
`((?<word>\w+)\s*)+`	Mettre en correspondance le motif d’un ou plusieurs caractères de mot suivis d’un ou plusieurs caractères d’espace blanc une ou plusieurs fois.
`(?<end>[.?!])`	Mettre en correspondance un point, un point d'interrogation ou un point d'exclamation. Affectez le caractère correspondant au `end` groupe de capture.

Remarques

Les groupes de capture sans nom et nommés sont accessibles par nombre. Les groupes sans nom sont numérotés de gauche à droite à partir de 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 à partir d’un nombre supérieur au nombre de groupes de capture sans nom.

Le référencement d’un groupe par son numéro au lieu d’un nom de chaîne peut fournir un accès plus rapide.

S’applique à

Partager via