Construcciones de agrupamiento

Actualización: noviembre 2007

Las construcciones de agrupamiento definen subexpresiones de una expresión regular y, normalmente, capturan subcadenas de una cadena de entrada. La tabla siguiente describe las construcciones de agrupamiento de expresiones regulares.

Construcción de agrupamiento	Descripción
(subexpresión)	Captura la subexpresión coincidente (o grupo sin captura; para obtener más información, vea la opción ExplicitCapture en Opciones de expresiones regulares). Las capturas que utilizan () se numeran automáticamente en función del orden del paréntesis de apertura, comenzando por el número uno. La primera captura, la captura de elemento número cero, es el texto que coincide con el modelo completo de la expresión regular.
(?<nombre>subexpresión)	Captura la subexpresión coincidente dentro de un nombre de grupo o nombre de número. La cadena que se utiliza para nombre no debe contener ningún signo de puntuación y no puede comenzar por un número. Se pueden utilizar comillas sencillas en vez de corchetes angulares; por ejemplo, (?'name').
(?<nombre1-nombre2>subexpresión)	(Definición de grupo de compensación.) Elimina la definición de nombre2 del grupo definido anteriormente y almacena en el nombre1 del grupo el intervalo entre el nombre2 del grupo definido anteriormente y el grupo actual. Si no se ha definido el nombre2 de grupo, retrocede en la búsqueda de coincidencia. Como al eliminar la última definición de nombre2 se revela la definición anterior de nombre2, esta construcción permite que la pila de capturas del nombre2 de grupo se utilice como un contador para realizar el seguimiento de construcciones anidadas como los paréntesis. En esta construcción nombre1 es opcional. Se pueden utilizar comillas sencillas, en vez de corchetes angulares; por ejemplo, (?'name1-name2'). Para obtener más información, vea el ejemplo de este tema.
(?:subexpresión)	(Grupo sin captura.) No captura la subcadena que coincide con la subexpresión.
(?imnsx-imnsx:subexpresión)	Aplica o deshabilita las opciones especificadas dentro de la subexpresión. Por ejemplo, (?i-s: ) activa la opción que no hace distinción entre mayúsculas y minúsculas y deshabilita el modo de una línea. Para obtener más información, vea Opciones de expresiones regulares.
(?=subexpresión)	(Aserción de búsqueda anticipada positiva de ancho igual a cero.) Continúa la búsqueda de coincidencias sólo si la subexpresión coincide a la derecha de esta posición. Por ejemplo, \w+(?=\d) coincide con una palabra seguida de un dígito, sin que coincida con el dígito. Esta construcción no tiene retroceso.
(?!subexpresión)	(Aserción de búsqueda anticipada negativa de ancho igual cero.) Continúa la búsqueda de coincidencias sólo si la subexpresión no coincide a la derecha de esta posición. Por ejemplo, \b(?!un)\w+\b coincide con las palabras que no comiencen por un.
(?<=subexpresión)	(Aserción de búsqueda tardía positiva de ancho igual a cero.) Continúa la búsqueda de coincidencias sólo si la subexpresión coincide a la izquierda de esta posición. Por ejemplo, (?<=19)99 coincide con las instancias de 99 que van después de 19. Esta construcción no tiene retroceso.
(?<!subexpresión)	(Aserción de búsqueda tardía negativa de ancho igual cero.) Continúa la búsqueda de coincidencias sólo si la subexpresión no coincide a la izquierda de esta posición.
(?>subexpresión)	(Subexpresión que no tiene retroceso, que también recibe el nombre de subexpresión expansiva.) La subexpresión coincide totalmente una vez y, a continuación, no participa de manera sistemática en el retroceso. (Es decir, la subexpresión coincide sólo con cadenas que coinciden únicamente con la subexpresión.) De forma predeterminada, si una coincidencia no es satisfactoria, el retroceso busca otras coincidencias posibles. Si sabe de antemano que el retroceso no puede ser satisfactorio, puede utilizar una subexpresión sin retroceso para impedir que se realice una búsqueda innecesaria, lo que mejora el rendimiento.

Las capturas con nombre se numeran de forma secuencial, de izquierda a derecha del paréntesis de apertura (igual que las capturas sin nombre), aunque la numeración de las capturas con nombre se inicia después de contar todas las capturas sin nombre. Por ejemplo, el modelo ((?<One>abc)\d+)?(?<Two>xyz)(.*) produce los siguientes grupos de captura por número y nombre. (La primera captura (la número 0) siempre hace referencia al modelo completo).

Número	Nombre	Modelo
0	0 (nombre predeterminado)	((?<One>abc)\d+)?(?<Two>xyz)(.*)
1	1 (nombre predeterminado)	((?<One>abc)\d+)
2	2 (nombre predeterminado)	(.*)
3	Uno	(?<One>abc)
4	Dos	(?<Two>xyz)

Ejemplo de definición de grupo de compensación

En el siguiente ejemplo de código se muestra cómo utilizar una definición de grupo de compensación para que coincida con los corchetes angulares izquierdo y derecho (<>) de una cadena de entrada. Las colecciones de captura de los grupos de apertura y cierre del ejemplo se utilizan como una pila para realizar un seguimiento de los pares de corchetes angulares coincidentes: cada corchete angular izquierdo capturado se inserta en la colección de captura del grupo de apertura; cada corchete angular derecho capturado se inserta en la colección de captura del grupo de cierre; y la definición de grupo de compensación garantiza haya un corchete angular derecho coincidente para cada corchete angular izquierdo.

' This code example demonstrates using the balancing group definition feature of 
' regular expressions to match balanced left angle bracket (<) and right angle 
' bracket (>) characters in a string. 

Imports System
Imports System.Text.RegularExpressions

Class Sample
    Public Shared Sub Main() 
'
'    The following expression matches all balanced left and right angle brackets(<>). 
'    The expression:
'    1)   Matches and discards zero or more non-angle bracket characters.
'    2)   Matches zero or more of:
'    2a)  One or more of:
'    2a1) A group named "Open" that matches a left angle bracket, followed by zero 
'         or more non-angle bracket characters. 
'         "Open" essentially counts the number of left angle brackets.
'    2b) One or more of:
'    2b1) A balancing group named "Close" that matches a right angle bracket, 
'         followed by zero or more non-angle bracket characters. 
'         "Close" essentially counts the number of right angle brackets.
'    3)   If the "Open" group contains an unaccounted for left angle bracket, the 
'        entire regular expression fails.
'
        Dim pattern As String = "^[^<>]*" & _
                                "(" + "((?'Open'<)[^<>]*)+" & _
                                "((?'Close-Open'>)[^<>]*)+" + ")*" & _
                                "(?(Open)(?!))$"
        Dim input As String = "<abc><mno<xyz>>"
'
        Dim m As Match = Regex.Match(input, pattern)
        If m.Success = True Then
            Console.WriteLine("Input: ""{0}"" " & vbCrLf & "Match: ""{1}""", _
                               input, m)
        Else
            Console.WriteLine("Match failed.")
        End If
    End Sub 'Main
End Class 'Sample 

'This code example produces the following results:
'
'Input: "<abc><mno<xyz>>"
'Match: "<abc><mno<xyz>>"
'

// This code example demonstrates using the balancing group definition feature of 
// regular expressions to match balanced left angle bracket (<) and right angle 
// bracket (>) characters in a string. 

using System;
using System.Text.RegularExpressions;

class Sample 
{
    public static void Main() 
    {
/*
    The following expression matches all balanced left and right angle brackets(<>). 
    The expression:
    1)   Matches and discards zero or more non-angle bracket characters.
    2)   Matches zero or more of:
    2a)  One or more of:
    2a1) A group named "Open" that matches a left angle bracket, followed by zero 
         or more non-angle bracket characters. 
         "Open" essentially counts the number of left angle brackets.
    2b) One or more of:
    2b1) A balancing group named "Close" that matches a right angle bracket, 
         followed by zero or more non-angle bracket characters. 
         "Close" essentially counts the number of right angle brackets.
    3)   If the "Open" group contains an unaccounted for left angle bracket, the 
        entire regular expression fails.
*/
    string pattern = "^[^<>]*" +
                     "(" + 
                       "((?'Open'<)[^<>]*)+" +
                       "((?'Close-Open'>)[^<>]*)+" +
                     ")*" +
                     "(?(Open)(?!))$";
    string input = "<abc><mno<xyz>>";
//
    Match m = Regex.Match(input, pattern);
    if (m.Success == true)
        Console.WriteLine("Input: \"{0}\" \nMatch: \"{1}\"", input, m);
    else
        Console.WriteLine("Match failed.");
    }
}

/*
This code example produces the following results:

Input: "<abc><mno<xyz>>"
Match: "<abc><mno<xyz>>"

*/

Vea también

Otros recursos

Elementos del lenguaje de expresiones regulares