Compartir vía


Regex.GroupNameFromNumber(Int32) Método

Definición

Obtiene el nombre de grupo que corresponde al número de grupo especificado.

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

i
Int32

Número de grupo para convertir al nombre de grupo correspondiente.

Devoluciones

Cadena que contiene el nombre de grupo asociado al número de grupo especificado. Si no hay un nombre de grupo que se corresponda con i, el método devuelve Empty.

Ejemplos

En el ejemplo siguiente se define un patrón de expresión regular que coincide con una línea de dirección que contiene un nombre de ciudad de EE. UU., un nombre de estado y un código postal. En el ejemplo se usa el GroupNameFromNumber método para recuperar los nombres de los grupos de captura. A continuación, usa estos nombres para recuperar los grupos capturados correspondientes para las coincidencias.

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.

El patrón de expresión regular se define mediante la expresión siguiente:

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

En la siguiente tabla se muestra cómo se interpreta el patrón de expresión regular.

Modelo Descripción
(?<city>[A-Za-z\s]+) Coincide con uno o varios caracteres alfabéticos o de espacio en blanco. Asigne a este grupo capturado el nombre city.
, Coincide con una coma (,) seguida de un carácter de espacio en blanco.
(?<state>[A-Za-z]{2}) Coincide con dos caracteres alfabéticos. Asigne a este grupo capturado el nombre state. Este grupo debe seguir un carácter de espacio en blanco.
(?<zip>\d{5}(-\d{4})?) Coincide con cinco dígitos numéricos seguidos de cero o una aparición de un guión seguido de cuatro dígitos. Asigne a este grupo capturado el nombre zip.

Comentarios

Un patrón de expresión regular puede contener grupos de captura con nombre o numerados, que delimitan subexpresiones dentro de una coincidencia de patrón. Los grupos numerados se delimitan por la sintaxis (subexpresión) y se asignan números en función de su orden en la expresión regular. Los grupos con nombre están delimitados por la sintaxis (?<Nombre>subexpresión) o (?' name'subexpression), donde name es el nombre por el que se identificará la subexpresión. (Para obtener más información, vea Construcciones de agrupación). El GroupNameFromNumber método identifica los grupos con nombre y los grupos numerados por sus posiciones ordinales en la expresión regular. La posición ordinal cero siempre representa toda la expresión regular. Todos los grupos numerados se cuentan antes de los grupos con nombre, independientemente de su posición real en el patrón de expresión regular.

Si i es el número de un grupo con nombre, el método devuelve el nombre del grupo. Si i es el número de un grupo sin nombre, el método devuelve la representación de cadena del número. Por ejemplo, si i es 1, el método devuelve "1". Si i no es el número de un grupo de captura, el método devuelve String.Empty.

Si se encuentra una coincidencia de patrón, el valor devuelto por este método se puede usar para recuperar el Group objeto que representa el grupo capturado de la GroupCollection.Item[] propiedad . La GroupCollection propiedad devuelve el Match.Groups objeto .

Se aplica a

Consulte también