Regex.GroupNameFromNumber(Int32) Método

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

public string GroupNameFromNumber (int i);

member this.GroupNameFromNumber : int -> string

Public Function GroupNameFromNumber (i As Integer) As String

Parâmetros

Retornos

Uma cadeia de caracteres que contém o nome de grupo associado ao número de grupo especificado. Se não houver nenhum nome de grupo que corresponda a i, o método retornará Empty.

Exemplos

O exemplo a seguir define um padrão de expressão regular que corresponde a uma linha de endereço que contém um nome da cidade dos EUA, um nome de estado e um cep. O exemplo usa o GroupNameFromNumber método para recuperar os nomes dos grupos de captura. Em seguida, ele usa esses nomes para recuperar os grupos capturados correspondentes para correspondências.

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.

O padrão de expressão regular é definido pela seguinte expressão:

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

A tabela a seguir mostra como o padrão da expressão regular é interpretado.

Comentários

Um padrão de expressão regular pode conter grupos de captura nomeados ou numerados, que delineam subexpressões dentro de uma correspondência de padrão. Os grupos numerados são delimitados pela sintaxe (subexpressão) e são atribuídos números com base em sua ordem na expressão regular. Os grupos nomeados são delimitados pela sintaxe (?<Nome>subexpression) ou (?' name'subexpression), em que name é o nome pelo qual a subexpressão será identificada. (Para obter mais informações, consulte Construções de agrupamento.) O GroupNameFromNumber método identifica grupos nomeados e grupos numerados por suas posições ordinais na expressão regular. A posição ordinal zero sempre representa toda a expressão regular. Todos os grupos numerados são contados antes dos grupos nomeados, independentemente de sua posição real no padrão de expressão regular.

Se i for o número de um grupo nomeado, o método retornará o nome do grupo. Se i for o número de um grupo sem nome, o método retornará a representação de cadeia de caracteres do número. Por exemplo, se i for 1, o método retornará "1". Se i não for o número de um grupo de captura, o método retornará String.Empty.

Se uma correspondência de padrão for encontrada, o valor retornado por esse método poderá ser usado para recuperar o Group objeto que representa o grupo capturado da GroupCollection.Item[] propriedade . O GroupCollection objeto é retornado pela Match.Groups propriedade .

Aplica-se a

Confira também

• GroupCollection
• GetGroupNumbers()
• Agrupando constructos em expressões regulares