Regex.GroupNameFromNumber(Int32) Méthode

public:
 System::String ^ GroupNameFromNumber(int i);

public string GroupNameFromNumber (int i);

member this.GroupNameFromNumber : int -> string

Public Function GroupNameFromNumber (i As Integer) As String

Paramètres

Retours

Chaîne qui contient le nom de groupe associé au numéro de groupe spécifié. Si aucun nom de groupe ne correspond à i, la méthode retourne Empty.

Exemples

L’exemple suivant définit un modèle d’expression régulière qui correspond à une ligne d’adresse contenant un nom de ville américaine, un nom d’état et un code postal. L’exemple utilise la GroupNameFromNumber méthode pour récupérer les noms des groupes de capture. Il utilise ensuite ces noms pour récupérer les groupes capturés correspondants pour les correspondances.

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(?<city>[A-Za-z\s]+), (?<state>[A-Za-z]{2}) (?<zip>\d{5}(-\d{4})?)";
      string[] cityLines = {"New York, NY 10003", "Brooklyn, NY 11238", "Detroit, MI 48204", 
                            "San Francisco, CA 94109", "Seattle, WA 98109" };
      Regex rgx = new Regex(pattern);
      List<string> names = new List<string>();
      int ctr = 1;
      bool exitFlag = false;
      // Get group names.
      do {
         string name = rgx.GroupNameFromNumber(ctr);
         if (! String.IsNullOrEmpty(name))
         {
            ctr++;
            names.Add(name);
         }
         else
         {
            exitFlag = true;
         }
      } while (! exitFlag);

      foreach (string cityLine in cityLines)
      {
         Match match = rgx.Match(cityLine);
         if (match.Success)
            Console.WriteLine("Zip code {0} is in {1}, {2}.", 
                               match.Groups[names[3]], 
                               match.Groups[names[1]], 
                               match.Groups[names[2]]);
      } 
   }
}
// The example displays the following output:
//       Zip code 10003 is in New York, NY.
//       Zip code 11238 is in Brooklyn, NY.
//       Zip code 48204 is in Detroit, MI.
//       Zip code 94109 is in San Francisco, CA.
//       Zip code 98109 is in Seattle, WA.

Imports System.Collections.Generic
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(?<city>[A-Za-z\s]+), (?<state>[A-Za-z]{2}) (?<zip>\d{5}(-\d{4})?)"
      Dim cityLines() As String = {"New York, NY 10003", "Brooklyn, NY 11238", "Detroit, MI 48204", _
                                   "San Francisco, CA 94109", "Seattle, WA 98109" }
      Dim rgx As New Regex(pattern)
      Dim names As New List(Of String)      
      Dim ctr As Integer = 1
      Dim exitFlag As Boolean = False
      ' Get group names.
      Do 
         Dim name As String = rgx.GroupNameFromNumber(ctr)
         If Not String.IsNullOrEmpty(name) Then
            ctr += 1
            names.Add(name)
         Else
            exitFlag = True
         End If
      Loop While Not exitFlag
      
      For Each cityLine As String In cityLines
         Dim match As Match = rgx.Match(cityLine)
         If match.Success Then
            Console.WriteLine("Zip code {0} is in {1}, {2}.", _
                               match.Groups.Item(names.Item(3)), _
                               match.Groups.Item(names.Item(1)), _
                               match.Groups.Item(names.Item(2)))
         End If   
      Next 
   End Sub
End Module
' The example displays the following output:
'       Zip code 10003 is in New York, NY.
'       Zip code 11238 is in Brooklyn, NY.
'       Zip code 48204 is in Detroit, MI.
'       Zip code 94109 is in San Francisco, CA.
'       Zip code 98109 is in Seattle, WA.

Le modèle d’expression régulière est défini par l’expression suivante :

(?<city>[A-Za-z\s]+), (?<state>[A-Za-z]{2}) (?<zip>\d{5}(-\d{4})?)

Le tableau suivant montre comment le modèle d'expression régulière est interprété.

Remarques

Un modèle d’expression régulière peut contenir des groupes de capture nommés ou numérotés, qui délimitent des sous-expressions dans une correspondance de modèle. Les groupes numérotés sont délimités par la syntaxe (sous-expression) et sont attribués en fonction de leur ordre dans l’expression régulière. Les groupes nommés sont délimités par la syntaxe (?<Nom>sous-expression) ou (? name’subexpression), où name est le nom par lequel la sous-expression sera identifiée. (Pour plus d’informations, consultez Constructions de regroupement.) La GroupNameFromNumber méthode identifie à la fois les groupes nommés et les groupes numérotés par leurs positions ordinales dans l’expression régulière. La position ordinale zéro représente toujours l’expression régulière entière. Tous les groupes numérotés sont ensuite comptés avant les groupes nommés, quelle que soit leur position réelle dans le modèle d’expression régulière.

Si i est le numéro d’un groupe nommé, la méthode retourne le nom du groupe. Si i est le numéro d’un groupe sans nom, la méthode retourne la représentation sous forme de chaîne du nombre. Par exemple, si i a la valeur 1, la méthode retourne « 1 ». Si i n’est pas le numéro d’un groupe de capture, la méthode retourne String.Empty.

Si une correspondance de modèle est trouvée, la valeur retournée par cette méthode peut ensuite être utilisée pour récupérer l’objet Group qui représente le groupe capturé à partir de la GroupCollection.Item[] propriété . L’objet GroupCollection est retourné par la Match.Groups propriété .

S’applique à

Voir aussi

• GroupCollection
• GetGroupNumbers()
• Constructions de regroupement dans les expressions régulières