Compartir a través de

Construcciones de agrupamiento

  • Artículo

Las construcciones de agrupamiento definen las subexpresiones de una expresión regular y capturan las subcadenas de una cadena de entrada. Puede utilizar construcciones de agrupación para hacer lo siguiente:

  • Buscar una subexpresión que se repite en la cadena de entrada.

  • Aplicar un cuantificador a una subexpresión que tiene varios elementos de lenguaje de la expresión regular. Para obtener más información sobre los cuantificadores, vea Cuantificadores.

  • Incluya una subexpresión en la cadena que es devuelta por los métodos Match.Result y Regex.Replace.

  • Recupere las subexpresiones individuales de la propiedad Match.Groups y procéselas por separado del texto coincidente en su conjunto.

.NET Framework admite la siguiente construcción de agrupamiento de expresiones regulares:

  • Subexpresiones que coinciden

  • Subexpresiones con nombre que coinciden

  • Definiciones de grupos de equilibrio

  • Grupos sin captura

  • Opciones de grupo

  • Aserciones de búsqueda anticipada positiva de ancho cero

  • Aserciones de búsqueda anticipada negativa de ancho cero

  • Aserciones de búsqueda tardía positiva de ancho cero

  • Aserciones de búsqueda tardía negativa de ancho cero

  • Subexpresiones sin retroceso

  • Construcciones de agrupamiento y objetos de expresiones regulares

Subexpresiones que coinciden

La construcción de agrupación siguiente captura una subexpresión coincidente:

( subexpresión )

donde la subexpresión es cualquier modelo de expresión regular válido. Las capturas que usan paréntesis se numeran automáticamente de izquierda a derecha según el orden de los paréntesis de apertura de la expresión regular, empezando desde uno. La captura con número cero es el texto coincidente con el modelo de expresión regular completo.

NotaNota

Si el parámetro RegexOptions de un método de coincidencia de modelos de expresión regular incluye la marca RegexOptions.ExplicitCapture, o si la opción n se aplica a esta subexpresión (vea Opciones de grupo posteriormente en este tema), no se captura la subexpresión coincidente.

Puede tener acceso a los grupos capturados de cuatro maneras:

  • Utilizando la construcción de referencia inversa dentro de la expresión regular. Se hace referencia a la subexpresión coincidente en la misma expresión regular utilizando la sintaxis \número, donde número es el número ordinal de la subexpresión capturada.

  • Utilizando la construcción de referencia inversa con nombre dentro de la expresión regular. Se hace referencia a la subexpresión coincidente en la misma expresión regular utilizando la sintaxis \k< número>, donde número es el número ordinal de la subexpresión capturada. La subexpresión capturada tiene un nombre predeterminado que es idéntico a su número ordinal. Para obtener más información, vea Subexpresiones con nombre que coinciden posteriormente en este tema.

  • Utilizando la secuencia de reemplazo $número en una llamada al método Regex.Replace o Match.Result, donde número es el número ordinal de la subexpresión capturada.

  • Mediante programación, usando el objeto GroupCollection devuelto por la propiedad Match.Groups. El miembro en la posición cero de la colección representa la coincidencia de toda la expresión regular. Cada miembro subsiguiente representa una subexpresión coincidente. Para obtener más información, vea la sección Construcciones de agrupamiento y objetos de expresiones regulares.

En el ejemplo siguiente se muestra una expresión regular que identifica las palabras duplicadas en el texto. Los dos grupos de captura del modelo de expresión regular representan las dos instancias de la palabra duplicada. La segunda instancia se captura para notificar su posición inicial en la cadena de entrada.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\w+)\s(\1)\W"
      Dim input As String = "He said that that was the the correct answer."
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine("Duplicate '{0}' found at positions {1} and {2}.", _
                           match.Groups(1).Value, match.Groups(1).Index, match.Groups(2).Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Duplicate 'that' found at positions 8 and 13.
'       Duplicate 'the' found at positions 22 and 26.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\w+)\s(\1)";
      string input = "He said that that was the the correct answer.";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine("Duplicate '{0}' found at positions {1} and {2}.", 
                           match.Groups[1].Value, match.Groups[1].Index, match.Groups[2].Index);
   }
}
// The example displays the following output:
//       Duplicate 'that' found at positions 8 and 13.
//       Duplicate 'the' found at positions 22 and 26.

El modelo de la expresión regular es el siguiente:

(\w+)\s(\1)\W

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

Modelo

Descripción

(\w+)

Buscar una coincidencia con uno o más caracteres de palabra. Éste es el primer grupo de captura.

\s

Hacer coincidir con un carácter que sea un espacio en blanco.

(\1)

Busque la cadena en el primer grupo capturado. Éste es el segundo grupo de captura. El ejemplo lo asigna a un grupo capturado para que la posición inicial de la palabra duplicada se pueda recuperar de la propiedad Match.Index.

\W

Busque un carácter que no sea palabra, espacios en blanco y puntuación incluidos. Esto evita que el modelo de expresión regular coincida con una palabra que comience con la palabra del primer grupo capturado.

Subexpresiones con nombre que coinciden

La construcción de agrupación siguiente captura una subexpresión coincidente y le permite tener acceso a ella por nombre o por número:

(?<name>subexpression)

O bien

(?'name' subexpression)

donde nombre es un nombre de grupo válido, y subexpresión es cualquier modelo de expresión regular válido. nombre no debe contener ningún carácter de puntuación y no puede comenzar por un número.

NotaNota

Si el parámetro RegexOptions de un método de coincidencia de modelos de expresión regular incluye la marca RegexOptions.ExplicitCapture, o si la opción n se aplica a esta subexpresión (vea Opciones de grupo posteriormente en este tema), la única forma de capturar una subexpresión es designar explícitamente grupos de captura.

Puede tener acceso a los grupos capturados con nombre de las maneras siguientes:

  • Utilizando la construcción de referencia inversa con nombre dentro de la expresión regular. Se hace referencia a la subexpresión coincidente en la misma expresión regular utilizando la sintaxis \k<nombre>, donde nombre es el nombre de la subexpresión capturada.

  • Utilizando la construcción de referencia inversa dentro de la expresión regular. Se hace referencia a la subexpresión coincidente en la misma expresión regular utilizando la sintaxis \número, donde número es el número ordinal de la subexpresión capturada. Las subexpresiones coincidentes con nombre se numeran consecutivamente de izquierda a derecha después de las subexpresiones coincidentes.

  • Utilizando la secuencia de reemplazo ${nombre} en una llamada al método Regex.Replace o Match.Result, donde nombre es el nombre de la subexpresión capturada.

  • Utilizando la secuencia de reemplazo $número> en una llamada al método Regex.Replace o Match.Result, donde número es el número ordinal de la subexpresión capturada.

  • Mediante programación, usando el objeto GroupCollection devuelto por la propiedad Match.Groups. El miembro en la posición cero de la colección representa la coincidencia de toda la expresión regular. Cada miembro subsiguiente representa una subexpresión coincidente. Los grupos con nombre capturados se almacenan en la colección después de los grupos capturados numerados.

  • Mediante programación, proporcionando el nombre de la subexpresión al indizador del objeto GroupCollection (en C#) o a su propiedad Item (en Visual Basic).

Un modelo de expresión regular simple muestra cómo se puede hacer referencia a los grupos numerados (sin nombre) y con nombre mediante programación o utilizando la sintaxis de lenguaje de expresiones regulares. La expresión regular ((?<One>abc)\d+)?(?<Two>xyz)(.*) produce los siguientes grupos de captura por número y por nombre. El primer grupo de captura (el número 0) siempre hace referencia al modelo completo.

Número

Name

Modelo

0

0 (nombre predeterminado)

((?<One>abc)\d+)?(?<Two>xyz)(.*)

1

1 (nombre predeterminado)

((?<One>abc)\d+)

2

2 (nombre predeterminado)

(.*)

3

One

(?<One>abc)

4

Dos

(?<Two>xyz)

En el ejemplo siguiente se muestra una expresión regular que identifica las palabras duplicadas y la palabra que sigue inmediatamente a cada palabra duplicada. El modelo de expresión regular define dos subexpresiones con nombre: duplicateWord, que representa la palabra duplicada; y nextWord, que representa la palabra que sigue a la palabra duplicada.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)"
      Dim input As String = "He said that that was the the correct answer."
      Console.WriteLine(Regex.Matches(input, pattern, RegexOptions.IgnoreCase).Count)
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine("A duplicate '{0}' at position {1} is followed by '{2}'.", _
                           match.Groups("duplicateWord").Value, match.Groups("duplicateWord").Index, _
                           match.Groups("nextWord").Value)
      Next
   End Sub
End Module
' The example displays the following output:
'    A duplicate 'that' at position 8 is followed by 'was'.
'    A duplicate 'the' at position 22 is followed by 'correct'.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)";
      string input = "He said that that was the the correct answer.";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine("A duplicate '{0}' at position {1} is followed by '{2}'.", 
                           match.Groups["duplicateWord"].Value, match.Groups["duplicateWord"].Index, 
                           match.Groups["nextWord"].Value);

   }
}
// The example displays the following output:
//       A duplicate 'that' at position 8 is followed by 'was'.
//       A duplicate 'the' at position 22 is followed by 'correct'.

El modelo de la expresión regular se define como sigue:

(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)

La tabla siguiente muestra cómo se interpreta la expresión regular.

Modelo

Descripción

(?<duplicateWord>\w+)

Buscar una coincidencia con uno o más caracteres de palabra. Asigne a este grupo de capturas el nombre duplicateWord.

\s

Hacer coincidir con un carácter que sea un espacio en blanco.

\k<duplicateWord>

Busque la cadena del grupo capturado denominada duplicateWord.

\W

Busque un carácter que no sea palabra, espacios en blanco y puntuación incluidos. Esto evita que el modelo de expresión regular coincida con una palabra que comience con la palabra del primer grupo capturado.

(?<nextWord>\w+)

Buscar una coincidencia con uno o más caracteres de palabra. Asigne a este grupo de capturas el nombre nextWord.

Definiciones de grupo de compensación

Una definición de grupo de compensación elimina la definición de un grupo definido anteriormente y almacena, en el grupo actual, el intervalo entre el grupo definido anteriormente y el grupo actual. Esta construcción de agrupación tiene el formato siguiente:

(?<name1-name2>subexpression)

O bien

(?'name1-name2' subexpression)

donde nombre1 es el grupo actual (opcional), nombre2 es un grupo previamente definido y subexpresión es cualquier modelo de expresión regular válido. La definición del grupo de equilibrio elimina la definición de nombre2 y almacena el intervalo entre nombre2 y nombre1 en nombre1. Si no se ha definido el grupo nombre2, la búsqueda de coincidencias retrocede. Como al eliminar la última definición de nombre2 se revela la definición anterior de nombre2, esta construcción permite usar la pila de capturas del grupo nombre2 como un contador para realizar el seguimiento de construcciones anidadas como paréntesis o corchetes de apertura y cierre.

La definición del grupo de equilibrio utiliza nombre2 como una pila. El carácter inicial de cada construcción anidada se coloca en el grupo y en su colección Group.Captures. Cuando se encuentra una coincidencia con el carácter de cierre, el carácter de apertura correspondiente se quita del grupo, y la colección Captures disminuye una unidad. Después de buscar los caracteres de apertura y cierre de todas las estructuras anidadas, nombre1 estará vacío.

NotaNota

Después de modificar la expresión regular en el ejemplo siguiente para utilizar el carácter de apertura y cierre adecuados de una construcción anidada, puede utilizarla para controlar la mayoría de las estructuras anidadas, como expresiones matemáticas o líneas de código de programa que incluyen varias llamadas a métodos anidadas.

En el siguiente ejemplo se utiliza una definición de grupo de compensación para que coincida con los corchetes angulares izquierdo y derecho (<>) de una cadena de entrada. En el ejemplo se definen dos grupos con nombre, Open y Close, que se utilizan como una pila para realizar el seguimiento de los pares de corchetes angulares coincidentes. Cada corchete angular de apertura capturado se inserta en la colección de captura del grupo Open, y cada corchete angular de cierre capturado se inserta en la colección de captura del grupo Close. La definición del grupo de equilibrio se asegura de que hay un corchete angular de cierre correspondiente para cada corchete angular de apertura. Si no lo hay, el submodelo final, (?(Open)(?!)), se evalúa solo si el grupo Open no está vacío (y, por consiguiente, si no se han cerrado todas las construcciones anidadas). Si se evalúa el último submodelo, se produce un error en la coincidencia, porque la cadena de entrada no debería contener ninguna aparición de la subcadena ?!.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main() 
        Dim pattern As String = "^[^<>]*" & _
                                "(" + "((?'Open'<)[^<>]*)+" & _
                                "((?'Close-Open'>)[^<>]*)+" + ")*" & _
                                "(?(Open)(?!))$"
        Dim input As String = "<abc><mno<xyz>>"
        Dim rgx AS New Regex(pattern)'
        Dim m As Match = Regex.Match(input, pattern)
        If m.Success Then
            Console.WriteLine("Input: ""{0}"" " & vbCrLf & "Match: ""{1}""", _
                               input, m)
            Dim grpCtr As Integer = 0
            For Each grp As Group In m.Groups
               Console.WriteLine("   Group {0}: {1}", grpCtr, grp.Value)
               grpCtr += 1
               Dim capCtr As Integer = 0
               For Each cap As Capture In grp.Captures            
                  Console.WriteLine("      Capture {0}: {1}", capCtr, cap.Value)
                  capCtr += 1
               Next
            Next
        Else
            Console.WriteLine("Match failed.")
        End If
    End Sub
End Module  
' The example displays the following output:
'       Input: "<abc><mno<xyz>>"
'       Match: "<abc><mno<xyz>>"
'          Group 0: <abc><mno<xyz>>
'             Capture 0: <abc><mno<xyz>>
'          Group 1: <mno<xyz>>
'             Capture 0: <abc>
'             Capture 1: <mno<xyz>>
'          Group 2: <xyz
'             Capture 0: <abc
'             Capture 1: <mno
'             Capture 2: <xyz
'          Group 3: >
'             Capture 0: >
'             Capture 1: >
'             Capture 2: >
'          Group 4:
'          Group 5: mno<xyz>
'             Capture 0: abc
'             Capture 1: xyz
'             Capture 2: mno<xyz>

using System;
using System.Text.RegularExpressions;

class Example
{
   public static void Main() 
   {
      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);
         int grpCtr = 0;
         foreach (Group grp in m.Groups)
         {
            Console.WriteLine("   Group {0}: {1}", grpCtr, grp.Value);
            grpCtr++;
            int capCtr = 0;
            foreach (Capture cap in grp.Captures)
            {            
                Console.WriteLine("      Capture {0}: {1}", capCtr, cap.Value);
                capCtr++;
            }
          }
      }
      else
      {
         Console.WriteLine("Match failed.");
      }   
    }
}
// The example displays the following output:
//    Input: "<abc><mno<xyz>>"
//    Match: "<abc><mno<xyz>>"
//       Group 0: <abc><mno<xyz>>
//          Capture 0: <abc><mno<xyz>>
//       Group 1: <mno<xyz>>
//          Capture 0: <abc>
//          Capture 1: <mno<xyz>>
//       Group 2: <xyz
//          Capture 0: <abc
//          Capture 1: <mno
//          Capture 2: <xyz
//       Group 3: >
//          Capture 0: >
//          Capture 1: >
//          Capture 2: >
//       Group 4:
//       Group 5: mno<xyz>
//          Capture 0: abc
//          Capture 1: xyz
//          Capture 2: mno<xyz>

El modelo de expresión regular es:

^[^<>]*(((?'Open'<)[^<>]*)+((?'Close-Open'>)[^<>]*)+)*(?(Open)(?!))$

La expresión regular se interpreta como sigue:

Modelo

Descripción

^

Comenzar al principio de la cadena.

[^<>]*

Busque cero o más caracteres que no son corchetes angulares de apertura o cierre.

(?'Open'<)

Busque un corchete angular de apertura y asígnelo a un grupo denominado Open.

[^<>]*

Busque cero o más caracteres que no son corchetes angulares de apertura o cierre.

((?'Open'<)[^<>]*) +

Busque una o más apariciones de un corchete angular de apertura seguido de cero o más caracteres que no son corchetes angulares de apertura o cierre. Éste es el segundo grupo de captura.

(?'Close-Open'>)

Busque un corchete angular de cierre, asigne la subcadena entre el grupo Open y el grupo actual al grupo Close, y elimine la definición del grupo Open.

[^<>]*

Busque cero o más apariciones de cualquier carácter que no sea un corchete angular de apertura ni cierre.

((?'Close-Open'>)[^<>]*)+

Busque una o más apariciones de un corchete angular de cierre, seguido de cero o más apariciones de cualquier carácter que no sea un corchete angular de apertura ni cierre. Al buscar una coincidencia con el corchete angular de cierre, asigne la subcadena entre el grupo Open y el grupo actual al grupo Close, y elimine la definición del grupo Open. Éste es el tercer grupo de captura.

(((?'Open'<)[^<>]*)+((?'Close-Open'>)[^<>]*)+)*

Busque cero o más apariciones del modelo siguiente: una o más apariciones de un corchete angular de apertura, seguidas por cero o más caracteres de corchetes no angulares, seguidas por una o más apariciones de un corchete angular de cierre, seguidas por cero o más apariciones de corchetes no angulares. Al buscar una coincidencia con el corchete angular de cierre, elimine la definición del grupo Open, y asigne la subcadena entre el grupo Open y el grupo actual al grupo Close. Éste es el primer grupo de captura.

(?(Open)(?!))

Si existe el grupo Open, busque coincidencias con un signo de interrogación y un signo de exclamación. Si se define el grupo Open, se produce un error en la coincidencia, que indica que los corchetes angulares no están equilibrados.

$

Buscar coincidencias con el final de la cadena de entrada.

La subexpresión final, (?(Open)(?!)), indica si las construcciones de anidamiento de la cadena de entrada están equilibradas correctamente (por ejemplo, si un corchete angular de cierre coincide con cada corchete angular de apertura). Utiliza concordancia condicional basada en un grupo capturado válido; para más información, vea Construcciones de alternancia. Si se define el grupo Open, el motor de expresiones regulares intenta buscar la subexpresión (?!) en la cadena de entrada. El grupo Open solo se debería definir si las estructuras de anidamiento están desequilibradas. Por consiguiente, el modelo del que se van a buscar coincidencias en la cadena de entrada debería ser uno que no se pueda producir en la cadena de entrada, lo cual provoca un error en la coincidencia.

En el ejemplo, el motor de expresiones regulares evalúa la cadena de entrada "<abc><mno<xyz>>" como se muestra en la siguiente tabla.

Paso

Modelo

Resultado

1

^

Comienza la búsqueda de coincidencias al principio de la cadena de entrada

2

[^<>]*

Busca caracteres de corchete no angulares antes del corchete angular de apertura; no encuentra ninguna coincidencia.

3

(((?'Open'<)

Busca una coincidencia con el corchete angular de apertura de "<abc>" y la asigna al grupo Open.

4

[^<>]*

Busca "abc".

5

)+

"<abc" es el valor del segundo grupo capturado.

El carácter siguiente de la cadena de entrada no es un corchete angular de apertura, de modo que el motor de expresiones regulares no retrocede al submodelo (?'Open'<)[^<>]*).

6

((?'Close-Open'>)

Busca una coincidencia con el corchete angular de cierre de "<abc>", asigna "abc", que es la subcadena entre el grupo Open y el corchete angular de cierre, al grupo Close, y elimina el valor actual ("<") del grupo Open, dejándolo vacío.

7

[^<>]*

Busca caracteres de corchete no angulares después del corchete angular de cierre; no encuentra ninguna coincidencia.

8

)+

El valor del tercer grupo capturado es ">".

El carácter siguiente de la cadena de entrada no es un corchete angular de cierre, de modo que el motor de expresiones regulares no retrocede al submodelo ((?'Close-Open'>)[^<>]*).

9

)*

El valor del primer grupo capturado es "<abc".

El carácter siguiente de la cadena de entrada es un corchete angular de apertura, de modo que el motor de expresiones regulares retrocede al submodelo (((?'Open'<).

10

(((?'Open'<)

Busca una coincidencia con el corchete angular de apertura de "<mno>" y la asigna al grupo Open. Su colección Group.Captures ahora tiene un valor único, "<".

11

[^<>]*

Busca "mno".

12

)+

"<mno" es el valor del segundo grupo capturado.

El carácter siguiente de la cadena de entrada es un corchete angular de apertura, de modo que el motor de expresiones regulares retrocede al submodelo (?'Open'<)[^<>]*).

13

(((?'Open'<)

Busca una coincidencia con el corchete angular de apertura de "<xyz>" y la asigna al grupo Open. La colección Group.Captures del grupo Open ahora incluye dos capturas: el corchete angular de apertura de "<mno>" y el corchete angular de apertura de "<xyz>".

14

[^<>]*

Busca "xyz".

15

)+

"<xyz" es el valor del segundo grupo capturado.

El carácter siguiente de la cadena de entrada no es un corchete angular de apertura, de modo que el motor de expresiones regulares no retrocede al submodelo (?'Open'<)[^<>]*).

16

((?'Close-Open'>)

Busca una coincidencia con el corchete angular de cierre de "<xyz>". " xyz", asigna la subcadena entre el grupo Open y el corchete angular de cierre al grupo Close, y elimina el valor actual del grupo Open. El valor de la captura anterior (el corchete angular de apertura de "<mno>") se vuelve el valor actual del grupo Open. La colección Captures del grupo Open ahora incluye una única captura, el corchete angular de apertura de "<xyz>".

17

[^<>]*

Busca caracteres de corchete no angulares; no encuentra ninguna coincidencia.

18

)+

El valor del tercer grupo capturado es ">".

El carácter siguiente de la cadena de entrada es un corchete angular de cierre, de modo que el motor de expresiones regulares retrocede al submodelo ((?'Close-Open'>)[^<>]*).

19

((?'Close-Open'>)

Busca una coincidencia con el último corchete angular de cierre de "xyz>>", asigna "mno<xyz>" (la subcadena entre el grupo Open y el corchete angular de cierre) al grupo Close, y elimina el valor actual del grupo Open. El grupo Open está ahora vacío.

20

[^<>]*

Busca caracteres de corchete no angulares; no encuentra ninguna coincidencia.

21

)+

El valor del tercer grupo capturado es ">".

El carácter siguiente de la cadena de entrada no es un corchete angular de cierre, de modo que el motor de expresiones regulares no retrocede al submodelo ((?'Close-Open'>)[^<>]*).

22

)*

El valor del primer grupo capturado es "<mno<xyz>>".

El carácter siguiente de la cadena de entrada no es un corchete angular de apertura, de modo que el motor de expresiones regulares no retrocede al submodelo (((?'Open'<).

23

(?(Open)(?!))

No se define el Open grupo, de modo que no se intenta ninguna coincidencia.

24

$

Busca una coincidencia con el final de la cadena de entrada.

Grupos sin captura

La construcción de agrupación siguiente no captura la subcadena con la que coincide una subexpresión:

(?:subexpression)

donde la subexpresión es cualquier modelo de expresión regular válido. La construcción de grupo sin captura se utiliza normalmente cuando un cuantificador se aplica a un grupo, pero las subcadenas capturadas por el grupo no tienen ningún interés.

NotaNota

Si una expresión regular incluye construcciones de agrupación anidadas, no se aplica una construcción de grupo no de captura exterior a las construcciones de grupo anidadas internas.

En el ejemplo siguiente se muestra una expresión regular que incluye grupos sin captura. Observe que la salida no incluye ningún grupo capturado.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(?:\b(?:\w+)\W*)+\."
      Dim input As String = "This is a short sentence."
      Dim match As Match = Regex.Match(input, pattern)
      Console.WriteLine("Match: {0}", match.Value)
      For ctr As Integer = 1 To match.Groups.Count - 1
         Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       Match: This is a short sentence.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(?:\b(?:\w+)\W*)+\.";
      string input = "This is a short sentence.";
      Match match = Regex.Match(input, pattern);
      Console.WriteLine("Match: {0}", match.Value);
      for (int ctr = 1; ctr < match.Groups.Count; ctr++)
         Console.WriteLine("   Group {0}: {1}", ctr, match.Groups[ctr].Value);
   }
}
// The example displays the following output:
//       Match: This is a short sentence.

La expresión regular (?:\b(?:\w+)\W*)+\. busca una frase que finaliza en un punto. Dado que la expresión regular se centra en frases y no en palabras individuales, las construcciones de agrupamiento se utilizan exclusivamente como cuantificadores. El modelo de expresión regular se interpreta como se muestra en la tabla siguiente.

Modelo

Descripción

\b

Iniciar la búsqueda de coincidencias en un límite de palabras.

(?:\w+)

Buscar una coincidencia con uno o más caracteres de palabra. No asigne el texto coincidente a un grupo capturado.

\W*

Buscar la coincidencia de cero o más caracteres que no pertenecen a una palabra.

(?:\b(?:\w+)\W*)+

Busque el modelo de uno o varios caracteres de palabra empezando en un límite de palabras de palabra, seguidos de cero o varios caracteres que no son de palabra, una o varias veces. No asigne el texto coincidente a un grupo capturado.

\.

Buscar coincidencias con un punto.

Opciones de grupo

La siguiente construcción de agrupación aplica o deshabilita las opciones especificadas dentro de una subexpresión:

(?imnsx-imnsx: subexpresión )

donde la subexpresión es cualquier modelo de expresión regular válido. 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 sobre las opciones alineadas que puede especificar, vea Opciones de expresiones regulares.

NotaNota

Puede especificar opciones que se apliquen a una expresión regular completa en lugar de a una subexpresión utilizando un constructor de clase System.Text.RegularExpressions.Regex o un método estático.También puede especificar opciones alineadas que se aplican después de un punto concreto en una expresión regular utilizando la construcción de lenguaje (?imnsx-imnsx).

La construcción de opciones de grupo no es un grupo de captura. Es decir, aunque cualquier parte de una cadena que es capturada por la subexpresión se incluye en la coincidencia, no se incluye en un grupo capturado ni se usa para rellenar el objeto GroupCollection.

Por ejemplo, la expresión regular \b(?ix: d \w+)\s del ejemplo siguiente utiliza las opciones alineadas de una construcción de agrupación para habilitar la concordancia sin distinción entre mayúsculas y minúsculas y omitir el espacio en blanco del modelo para identificar todas las palabras que comienzan con la letra "d". La expresión regular se define como se muestra en la tabla siguiente.

Modelo

Descripción

\b

Iniciar la búsqueda de coincidencias en un límite de palabras.

(?ix: d \w+)

Utilizando una coincidencia sin distinción entre mayúsculas y minúsculas y omitiendo los espacios en blanco en este modelo, busque coincidencias de una "d" seguida de uno o más caracteres de palabra.

\s

Hacer coincidir con un carácter que sea un espacio en blanco.

 
Dim pattern As String = "\b(?ix: d \w+)\s"
Dim input As String = "Dogs are decidedly good pets."

For Each match As Match In Regex.Matches(input, pattern)
   Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'    'Dogs ' found at index 0.
'    'decidedly ' found at index 9.      

string pattern = @"\b(?ix: d \w+)\s";
string input = "Dogs are decidedly good pets.";

foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
// The example displays the following output:
//    'Dogs // found at index 0.
//    'decidedly // found at index 9.

Aserciones de búsqueda anticipada positiva de ancho cero

La construcción de agrupación siguiente define una aserción de búsqueda anticipada positiva de ancho cero:

(?= subexpresión )

donde la subexpresión es cualquier modelo de expresión regular. Para que una coincidencia sea correcta, la cadena de entrada debe coincidir con el modelo de expresión regular de la subexpresión, aunque la subcadena coincidente no está incluida en el resultado de la coincidencia. Una aserción de búsqueda anticipada positiva de ancho cero no tiene retroceso.

Normalmente, una aserción de búsqueda anticipada positiva de ancho cero se encuentra al final de un modelo de expresión regular. Define una subcadena que se debe encontrar al final de una cadena para que se produzca una coincidencia, pero que no debería incluirse en la coincidencia. También resulta útil para evitar un retroceso excesivo. Puede utilizar una aserción de búsqueda anticipada positiva de ancho cero para garantizar que un grupo capturado determinado comienza con el texto que coincide con un subconjunto del modelo definido para dicho grupo capturado. Por ejemplo, si un grupo de captura coincide con caracteres de palabra consecutivos, puede utilizar una aserción de búsqueda anticipada positiva de ancho cero para requerir que el primero de los caracteres sea alfabético en mayúsculas.

En el ejemplo siguiente se utiliza una aserción de búsqueda anticipada positiva de ancho cero para buscar la palabra que precede al verbo "is" en la cadena de entrada.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+(?=\sis\b)"
      Dim inputs() As String = { "The dog is a Malamute.", _
                                 "The island has beautiful birds.", _
                                 "The pitch missed home plate.", _
                                 "Sunday is a weekend day." }

      For Each input As String In inputs
         Dim match As Match = Regex.Match(input, pattern)
         If match.Success Then
            Console.WriteLine("'{0}' precedes 'is'.", match.Value)
         Else
            Console.WriteLine("'{0}' does not match the pattern.", input) 
         End If     
      Next
   End Sub
End Module
' The example displays the following output:
'       'dog' precedes 'is'.
'       'The island has beautiful birds.' does not match the pattern.
'       'The pitch missed home plate.' does not match the pattern.
'       'Sunday' precedes 'is'.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+(?=\sis\b)";
      string[] inputs = { "The dog is a Malamute.", 
                          "The island has beautiful birds.", 
                          "The pitch missed home plate.", 
                          "Sunday is a weekend day." };

      foreach (string input in inputs)
      {
         Match match = Regex.Match(input, pattern);
         if (match.Success)
            Console.WriteLine("'{0}' precedes 'is'.", match.Value);
         else
            Console.WriteLine("'{0}' does not match the pattern.", input); 
      }
   }
}
// The example displays the following output:
//    'dog' precedes 'is'.
//    'The island has beautiful birds.' does not match the pattern.
//    'The pitch missed home plate.' does not match the pattern.
//    'Sunday' precedes 'is'.

La expresión regular \b\w+(?=\sis\b) se interpreta como se muestra en la tabla siguiente.

Modelo

Descripción

\b

Iniciar la búsqueda de coincidencias en un límite de palabras.

\w+

Buscar una coincidencia con uno o más caracteres de palabra.

(?=\sis\b)

Determine si los caracteres de palabra van seguidos por un carácter de espacio en blanco y la cadena "is", que finaliza en un límite de palabras. En ese caso, la coincidencia es correcta.

Aserciones de búsqueda anticipada negativa de ancho cero

La construcción de agrupación siguiente define una aserción de búsqueda anticipada negativa de ancho cero:

(?! subexpresión )

donde la subexpresión es cualquier modelo de expresión regular. Para que la coincidencia sea correcta, la cadena de entrada no debe coincidir con el modelo de expresión regular de la subexpresión, aunque la cadena coincidente no está incluida en el resultado de la coincidencia.

Una aserción de búsqueda anticipada negativa de ancho cero se utiliza normalmente al principio o al final de una expresión regular. Al principio de una expresión regular, puede definir un modelo concreto que no se debería buscar cuando el principio de la expresión regular define un modelo similar pero más general que se desea buscar. En este caso, se usa a menudo para limitar el retroceso. Al final de una expresión regular, puede definir una subexpresión que no se puede producir al final de una coincidencia.

En el ejemplo siguiente se define una expresión regular que utiliza una aserción de búsqueda anticipada de ancho cero al principio de la expresión regular para buscar palabras que no comienzan por "un".

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(?!un)\w+\b"
      Dim input As String = "unite one unethical ethics use untie ultimate"
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine(match.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       one
'       ethics
'       use
'       ultimate

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(?!un)\w+\b";
      string input = "unite one unethical ethics use untie ultimate";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       one
//       ethics
//       use
//       ultimate

La expresión regular \b(?!un)\w+\b se interpreta como se muestra en la tabla siguiente.

Modelo

Descripción

\b

Iniciar la búsqueda de coincidencias en un límite de palabras.

(?!un)

Determine si los dos caracteres siguientes son "un". Si no lo son, es posible una coincidencia.

\w+

Buscar una coincidencia con uno o más caracteres de palabra.

\b

Finalizar la búsqueda de coincidencias en un límite de palabras.

En el ejemplo siguiente se define una expresión regular que utiliza una aserción de búsqueda anticipada de ancho cero al final de la expresión regular para buscar palabras que no terminan con un carácter de puntuación.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+\b(?!\p{P})"
      Dim input As String = "Disconnected, disjointed thoughts in a sentence fragment."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next   
   End Sub
End Module
' The example displays the following output:
'       disjointed
'       thoughts
'       in
'       a
'       sentence

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+\b(?!\p{P})";
      string input = "Disconnected, disjointed thoughts in a sentence fragment.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       disjointed
//       thoughts
//       in
//       a
//       sentence

La expresión regular \b\w+\b(?!\p{P}) se interpreta como se muestra en la tabla siguiente.

Modelo

Descripción

\b

Iniciar la búsqueda de coincidencias en un límite de palabras.

\w+

Buscar una coincidencia con uno o más caracteres de palabra.

\b

Finalizar la búsqueda de coincidencias en un límite de palabras.

\p{P})

Si el carácter siguiente no es un símbolo de puntuación (como un punto o una coma), la coincidencia tiene éxito.

Aserciones de búsqueda tardía positiva de ancho cero

La construcción de agrupación siguiente define una aserción de búsqueda tardía positiva de ancho cero:

(?<= subexpresión )

donde la subexpresión es cualquier modelo de expresión regular. Para que una coincidencia sea correcta, la subexpresión se debe producir en la cadena de entrada a la izquierda de la posición actual, aunque subexpression no está incluido en el resultado de la coincidencia. Una aserción de búsqueda tardía positiva de ancho cero no tiene retroceso.

Las aserciones de búsqueda tardía positiva de ancho cero se utilizan normalmente al principio de las expresiones regulares. El modelo que definen es una condición previa de una coincidencia, aunque no forma parte del resultado de la coincidencia.

Por ejemplo, el ejemplo siguiente busca coincidencias con los dos últimos dígitos del año para el siglo XXI (es decir, requiere que los dígitos "20" precedan a la cadena coincidente).

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "2010 1999 1861 2140 2009"
      Dim pattern As String = "(?<=\b20)\d{2}\b"

      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next      
   End Sub
End Module
' The example displays the following output:
'       10
'       09

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "2010 1999 1861 2140 2009";
      string pattern = @"(?<=\b20)\d{2}\b";

      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       10
//       09

El modelo de expresión regular (?<=\b20)\d{2}\b se interpreta como se muestra en la tabla siguiente.

Modelo

Descripción

\d{2}

Buscar coincidencias con dos dígitos decimales.

{?<=\b20)

Continúe la búsqueda si los dos dígitos decimales van precedidos de los dos dígitos "20" decimales en un límite de palabras.

\b

Finalizar la búsqueda de coincidencias en un límite de palabras.

Las aserciones de búsqueda tardía positiva de ancho cero también se utilizan para limitar el retroceso cuando el último carácter o caracteres de un grupo capturado debe ser un subconjunto de los caracteres que coincide con el modelo de expresión regular de dicho grupo. Por ejemplo, si un grupo captura todos los caracteres de palabra consecutivos, puede utilizar una aserción de búsqueda tardía positiva de ancho igual a cero para requerir que el último carácter sea alfabético.

Aserciones de búsqueda tardía negativa de ancho cero

La construcción de agrupación siguiente define una aserción de búsqueda tardía negativa de ancho cero:

(?<! subexpresión )

donde la subexpresión es cualquier modelo de expresión regular. Para que una coincidencia sea correcta, la subexpresión no se debe producir en la cadena de entrada a la izquierda de la posición actual. Sin embargo, cualquier subcadena que no coincida con subexpression no se incluye en el resultado de la coincidencia.

Las aserciones de búsqueda tardía negativa de ancho cero se utilizan normalmente al principio de las expresiones regulares. El modelo que definen impide una coincidencia en la cadena que sigue. También se usan para limitar el retroceso cuando el último carácter o caracteres de un grupo capturado no debe ser uno o varios de los caracteres que coinciden con el modelo de expresión regular de dicho grupo. Por ejemplo, si un grupo captura todos los caracteres de palabra consecutivos, puede utilizar una aserción de búsqueda tardía positiva de ancho igual a cero para requerir que el último carácter no sea de subrayado (_).

El ejemplo siguiente busca la fecha de cualquier día de la semana que no sea fin de semana (es decir, que no sea ni sábado ni domingo).

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim dates() As String = { "Monday February 1, 2010", _
                                "Wednesday February 3, 2010", _
                                "Saturday February 6, 2010", _
                                "Sunday February 7, 2010", _
                                "Monday, February 8, 2010" }
      Dim pattern As String = "(?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b"

      For Each dateValue As String In dates
         Dim match As Match = Regex.Match(dateValue, pattern)
         If match.Success Then
            Console.WriteLine(match.Value)
         End If   
      Next      
   End Sub
End Module
' The example displays the following output:
'       February 1, 2010
'       February 3, 2010
'       February 8, 2010

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] dates = { "Monday February 1, 2010", 
                         "Wednesday February 3, 2010", 
                         "Saturday February 6, 2010", 
                         "Sunday February 7, 2010", 
                         "Monday, February 8, 2010" };
      string pattern = @"(?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b";

      foreach (string dateValue in dates)
      {
         Match match = Regex.Match(dateValue, pattern);
         if (match.Success)
            Console.WriteLine(match.Value);
      }      
   }
}
// The example displays the following output:
//       February 1, 2010
//       February 3, 2010
//       February 8, 2010

El modelo de expresión regular (?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b se interpreta como se muestra en la tabla siguiente.

Modelo

Descripción

\b

Iniciar la búsqueda de coincidencias en un límite de palabras.

\w+

Buscar la coincidencia de uno o varios caracteres de palabra seguidos de un espacio en blanco.

\d{1,2},

Busque uno o dos dígitos decimales seguidos por un carácter de espacio en blanco y una coma.

\d{4}\b

Busque cuatro dígitos decimales y finalice la búsqueda en un límite de palabras.

(?<!(Saturday|Sunday) )

Si la coincidencia va precedida por algo distinto de las cadenas "sábado" o "domingo" seguidas por un espacio, la coincidencia es correcta.

Subexpresiones sin retroceso

La construcción de agrupación siguiente representa una subexpresión sin retroceso (también conocida como subexpresión "expansiva"):

(?> subexpresión )

donde la subexpresión es cualquier modelo de expresión regular.

Comúnmente, si una expresión regular incluye un modelo de coincidencia opcional o alternativo y una coincidencia no tiene éxito, el motor de expresiones regulares puede crear una bifurcación en varias direcciones para buscar coincidencias de una cadena de entrada con un modelo. Si no se encuentra una coincidencia cuando toma la primera bifurcación, el motor de expresiones regulares puede regresar o retroceder al punto donde tomó la primera coincidencia e intentó la coincidencia usando la segunda bifurcación. Este proceso puede continuar hasta que se hayan probado todas las bifurcaciones.

La construcción de lenguaje (?> subexpresión) deshabilita el retroceso. El motor de expresiones regulares buscará coincidencias con tantos caracteres de la cadena de entrada como pueda. Cuando ya no son posibles más coincidencias, no retrocederá para intentar coincidencias del modelo alternativas. (Es decir, la subexpresión solo busca cadenas que coincidan exclusivamente con la subexpresión; no intenta buscar una cadena basada en la subexpresión y cualquier subexpresión que la sigue).

Se recomienda esta opción si sabe que el retroceso no tendrá éxito. Si se evita que el motor de expresiones regulares realice búsquedas innecesarias, se mejora rendimiento.

El ejemplo siguiente muestra cómo una subexpresión sin retroceso modifica los resultados de una coincidencia de modelos. La expresión regular con retroceso coincide correctamente con una serie de caracteres repetidos seguidos por una aparición más del mismo carácter en un límite de palabras, pero la expresión regular sin retroceso no lo hace.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim inputs() As String = { "cccd.", "aaad", "aaaa" }
      Dim back As String = "(\w)\1+.\b"
      Dim noback As String = "(?>(\w)\1+).\b"

      For Each input As String In inputs
         Dim match1 As Match = Regex.Match(input, back)
         Dim match2 As Match = Regex.Match(input, noback)
         Console.WriteLine("{0}: ", input)

         Console.Write("   Backtracking : ")
         If match1.Success Then
            Console.WriteLine(match1.Value)
         Else
            Console.WriteLine("No match")
         End If

         Console.Write("   Nonbacktracking: ")
         If match2.Success Then
            Console.WriteLine(match2.Value)
         Else
            Console.WriteLine("No match")
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'    cccd.:
'       Backtracking : cccd
'       Nonbacktracking: cccd
'    aaad:
'       Backtracking : aaad
'       Nonbacktracking: aaad
'    aaaa:
'       Backtracking : aaaa
'       Nonbacktracking: No match

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "cccd.", "aaad", "aaaa" };
      string back = @"(\w)\1+.\b";
      string noback = @"(?>(\w)\1+).\b";

      foreach (string input in inputs)
      {
         Match match1 = Regex.Match(input, back);
         Match match2 = Regex.Match(input, noback);
         Console.WriteLine("{0}: ", input);

         Console.Write("   Backtracking : ");
         if (match1.Success)
            Console.WriteLine(match1.Value);
         else
            Console.WriteLine("No match");

         Console.Write("   Nonbacktracking: ");
         if (match2.Success)
            Console.WriteLine(match2.Value);
         else
            Console.WriteLine("No match");
      }
   }
}
// The example displays the following output:
//    cccd.:
//       Backtracking : cccd
//       Nonbacktracking: cccd
//    aaad:
//       Backtracking : aaad
//       Nonbacktracking: aaad
//    aaaa:
//       Backtracking : aaaa
//       Nonbacktracking: No match

El modelo de expresión regular sin retroceso (?>(\w)\1+).\b se define como se muestra en la tabla siguiente.

Modelo

Descripción

(\w)

Buscar la coincidencia de un único carácter de palabra y asignarla al primer grupo de capturas.

\1+

Busque el valor de la primera subcadena capturada una o más veces.

.

Busque cualquier carácter.

\b

Finalizar la búsqueda de coincidencias en un límite de palabras.

(?>(\w)\1+)

Busque una o más apariciones de un carácter de palabra duplicado, pero no retroceda para buscar el último carácter en un límite de palabras.

Construcciones de agrupamiento y objetos de expresiones regulares

Los objetos System.Text.RegularExpressions.Group representan las subcadenas con las que coincide un grupo de captura de la expresión regular, que se puede recuperar del objeto System.Text.RegularExpressions.GroupCollection que devuelve la propiedad Match.Groups. El objeto GroupCollection se rellena como sigue:

  • El primer objeto Group de la colección (el objeto en el índice cero) representa la coincidencia completa.

  • El siguiente conjunto de objetos Group representa los grupos de captura sin nombre (numerados). Aparecen en el orden en el que se definen en la expresión regular, de izquierda a derecha. Los valores de índice de estos grupos van de 1 al número de grupos de captura sin nombre de la colección. (El índice de un grupo determinado es equivalente a su referencia inversa numerada. Para obtener más información sobre las referencias inversas, vea Construcciones de referencia inversa).

  • El conjunto final de objetos Group representa los grupos de captura con nombre. Aparecen en el orden en el que se definen en la expresión regular, de izquierda a derecha. El valor de índice del primer grupo de captura con nombre es una unidad mayor que el índice del último grupo de captura sin nombre. Si no hay ningún grupo de captura sin nombre en la expresión regular, el valor de índice del primer grupo de captura con nombre es cero.

Si aplica un cuantificador a un grupo de captura, las propiedades Capture.Value, Capture.Length y Capture.Index del objeto Group correspondiente reflejarán la última subcadena que es capturada por un grupo de captura. Puede recuperar un conjunto completo de subcadenas que son capturadas por grupos que tienen cuantificadores del objeto CaptureCollection que es devuelto por la propiedad Group.Captures.

El ejemplo siguiente clarifica la relación entre los objetos Group y Capture.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\b(\w+)\W+)+"
      Dim input As String = "This is a short sentence."
      Dim match As Match = Regex.Match(input, pattern)
      Console.WriteLine("Match: {0}", match.Value)
      For ctr As Integer = 1 To match.Groups.Count - 1
         Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
         Dim capCtr As Integer = 0
         For Each capture As Capture In match.Groups(ctr).Captures
            Console.WriteLine("      Capture {0}: {1}", capCtr, capture.Value)
            capCtr += 1
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'       Match: This is a short sentence.
'          Group 1: sentence.
'             Capture 0: This
'             Capture 1: is
'             Capture 2: a
'             Capture 3: short
'             Capture 4: sentence.
'          Group 2: sentence
'             Capture 0: This
'             Capture 1: is
'             Capture 2: a
'             Capture 3: short
'             Capture 4: sentence

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\b(\w+)\W+)+";
      string input = "This is a short sentence.";
      Match match = Regex.Match(input, pattern);
      Console.WriteLine("Match: {0}", match.Value);
      for (int ctr = 1; ctr < match.Groups.Count; ctr++)
      {
         Console.WriteLine("   Group {0}: {1}", ctr, match.Groups[ctr].Value);
         int capCtr = 0;
         foreach (Capture capture in match.Groups[ctr].Captures)
         {
            Console.WriteLine("      Capture {0}: {1}", capCtr, capture.Value);
            capCtr++;
         }
      }
   }
}
// The example displays the following output:
//       Match: This is a short sentence.
//          Group 1: sentence.
//             Capture 0: This
//             Capture 1: is
//             Capture 2: a
//             Capture 3: short
//             Capture 4: sentence.
//          Group 2: sentence
//             Capture 0: This
//             Capture 1: is
//             Capture 2: a
//             Capture 3: short
//             Capture 4: sentence

El modelo de expresión regular \b(\w+)\W+)+ extrae palabras individuales de una cadena. Se define como se muestra en la tabla siguiente.

Modelo

Descripción

\b

Iniciar la búsqueda de coincidencias en un límite de palabras.

(\w+)

Buscar una coincidencia con uno o más caracteres de palabra. Juntos, estos caracteres forman una palabra. Éste es el segundo grupo de captura.

\W+

Buscar coincidencias con uno o más caracteres que no sean palabras.

(\w+)\W+)+

Busque el modelo de uno o varios caracteres de palabra seguidos de uno o varios caracteres que no son de palabra, una o varias veces. Éste es el primer grupo de captura.

El primer grupo de captura busca coincidencias de cada palabra de la frase. El segundo grupo de captura busca coincidencias de cada palabra, junto con la puntuación y el espacio en blanco que siguen a la palabra. El objeto Group cuyo índice es 2 proporciona información sobre el texto coincidente con el segundo grupo de captura. El conjunto de palabras completo capturado por el grupo de captura está disponible desde el objeto CaptureCollection devuelto por la propiedad Group.Captures.

Vea también

Conceptos

Elementos del lenguaje de expresiones regulares

Retroceso