Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

Construcciones de agrupamiento en expresiones regulares

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 agrupamiento 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 del lenguaje de expresiones regulares. Para obtener más información sobre los cuantificadores, vea Cuantificadores en expresiones regulares.

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

  • Recuperar subexpresiones individuales de la propiedad Match.Groups y procesarlas por separado del texto coincidente en su conjunto.

.NET Framework admite las siguientes construcciones de agrupamiento de expresiones regulares:

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

( subexpression )

donde subexpression es cualquier patrón 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 el número cero es el texto coincidente con el patrón de la expresión regular completa.

Nota Nota

La subexpresión coincidente no se captura si el parámetro RegexOptions del método de coincidencia de patrones de una expresión regular incluye la marca RegexOptions.ExplicitCapture, o si se aplica la opción n a esta subexpresión (vea Opciones de grupo más adelante en este tema).

Existen cuatro formas de tener acceso a los grupos capturados:

  • Usando la construcción de referencia inversa dentro de la expresión regular. Para hacer referencia a la subexpresión coincidente desde la misma expresión regular se usa la sintaxis \number, donde number es el número ordinal de la subexpresión capturada.

  • Usando la construcción de referencia inversa con nombre dentro de la expresión regular. Para hacer referencia a la subexpresión coincidente desde la misma expresión regular se usa la sintaxis \k<name>, donde name es el nombre de un grupo de captura, o \k<number>, donde number es el número ordinal de un grupo de captura. Un grupo de captura tiene un nombre predeterminado que es idéntico a su número ordinal. Para obtener más información, vea Subexpresiones coincidentes con nombre más adelante en este tema.

  • Usando la secuencia de reemplazo $number en una llamada al método Regex.Replace o Match.Result, donde number 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 la expresión regular completa. Cada miembro subsiguiente representa una subexpresión coincidente. Para obtener más información, vea la sección Construcciones de agrupamiento y objetos de las 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 patrón de la 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.


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 patrón de la expresión regular es el siguiente:

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

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

Modelo

Descripción

(\w+)

Coincide con uno o varios caracteres que se usan para formar palabras. Éste es el primer grupo de captura.

\s

Buscar coincidencias con un carácter que sea un espacio en blanco.

(\1)

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

\W

Coincide con un carácter que no se usa para formar palabras, como los espacios en blanco y los signos de puntuación. Esto evita que el patrón de la expresión regular coincida con una palabra que comience por la palabra del primer grupo capturado.

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

(?<name>subexpression)

O bien

(?'name' subexpression)

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

NotaNota

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

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

  • Usando la construcción de referencia inversa con nombre dentro de la expresión regular. Para hacer referencia a la subexpresión coincidente desde la misma expresión regular se usa la sintaxis \k<name>, donde name es el nombre de la subexpresión capturada.

  • Usando la construcción de referencia inversa dentro de la expresión regular. Para hacer referencia a la subexpresión coincidente desde la misma expresión regular se usa la sintaxis \number, donde number 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.

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

  • Usando la secuencia de reemplazo $number en una llamada al método Regex.Replace o Match.Result, donde number 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 la expresión regular completa. Cada miembro subsiguiente representa una subexpresión coincidente. Los grupos capturados con nombre 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 patrón 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 del 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 patrón 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

One

(?<One>abc)

4

Two

(?<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 patrón de la 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.


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 patrón de la expresión regular es el siguiente:

(?<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+)

Coincide con uno o varios caracteres que se usan para formar palabras. Este grupo de captura se denomina duplicateWord.

\s

Buscar coincidencias con un carácter que sea un espacio en blanco.

\k<duplicateWord>

Coincide con la cadena del grupo capturado denominada duplicateWord.

\W

Coincide con un carácter que no se usa para formar palabras, como los espacios en blanco y los signos de puntuación. Esto evita que el patrón de la expresión regular coincida con una palabra que comience por la palabra del primer grupo capturado.

(?<nextWord>\w+)

Coincide con uno o varios caracteres que se usan para formar palabras. Este grupo de captura se denomina nextWord.

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 agrupamiento tiene el formato siguiente:

(?<name1-name2>subexpression)

O bien

(?'name1-name2' subexpression)

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

La definición del grupo de compensación utiliza name2 como 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 en una unidad. Después de buscar las coincidencias con los caracteres de apertura y cierre de todas las construcciones anidadas, name1 estará vacío.

NotaNota

Después de modificar la expresión regular del ejemplo siguiente para que utilice el carácter de apertura y cierre adecuado de una construcción anidada, puede utilizarla con 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 ejemplo siguiente se usa una definición de grupo de compensación para que coincida con los corchetes angulares de apertura y de cierre (<>) 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. Mediante la definición del grupo de compensación se comprueba que haya un corchete angular de cierre para cada corchete angular de apertura. Si no lo hay, el subpatrón 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 subpatrón final, la coincidencia produce un error, porque el subpatrón (?!) es una aserción de búsqueda anticipada negativa de ancho cero que siempre produce un error.


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 patrón de la expresión regular es:

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

La expresión regular se interpreta como sigue:

Modelo

Descripción

^

Comienza al principio de la cadena.

[^<>]*

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

(?'Open'<)

Coincide con un corchete angular de apertura y se lo asigna a un grupo denominado Open.

[^<>]*

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

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

Coincide con 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'>)

Coincide con un corchete angular de cierre, asigna la subcadena entre el grupo Open y el grupo actual al grupo Close y elimina la definición del grupo Open.

[^<>]*

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

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

Coincide con 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 de cierre. Al buscar una coincidencia con el corchete angular de cierre, asigna la subcadena entre el grupo Open y el grupo actual al grupo Close, y elimina la definición del grupo Open. Éste es el tercer grupo de captura.

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

Coincide con cero o más apariciones del patrón siguiente: una o varias apariciones de un corchete angular de apertura, seguidas de cero o más caracteres que no sean corchetes angulares, seguidas de una o más apariciones de un corchete angular de cierre, seguidas de cero o más apariciones de caracteres que no sean corchetes angulares. Al buscar una coincidencia con el corchete angular de cierre, borra la definición del grupo Open y asigna 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, abandona la coincidencia si se encuentra una cadena vacía, pero no avanza la posición del motor de expresiones regulares en la cadena. Esta es una aserción de búsqueda anticipada negativa de ancho cero. Dado que siempre existe implícitamente una cadena vacía en una cadena de entrada, esta coincidencia siempre produce un error. Un error en esta coincidencia indica que no hay el mismo número de corchetes angulares de apertura y de cierre.

$

Coincide 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 compensadas correctamente (por ejemplo, si cada corchete angular de apertura coincide con un corchete angular de cierre). Utiliza la coincidencia condicional basada en un grupo capturado válido; para obtener más información, vea Construcciones de alternancia en expresiones regulares. 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 construcciones de anidamiento están descompensadas. Por consiguiente, el patrón que se va a comparar en la cadena de entrada debe ser uno que siempre produzca un error en la coincidencia. En este caso, (?!) es una aserción de búsqueda anticipada negativa de ancho cero que siempre produce un error, porque siempre existe implícitamente una cadena vacía en la posición siguiente de la cadena de entrada.

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

Paso

Modelo

Resultado

1

^

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

2

[^<>]*

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

3

(((?'Open'<)

Encuentra el corchete angular de apertura de "<abc>" y se lo asigna al grupo Open.

4

[^<>]*

Encuentra "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, por lo que el motor de expresiones regulares no retrocede al subpatrón (?'Open'<)[^<>]*).

6

((?'Close-Open'>)

Encuentra 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 que no sean corchetes 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, por lo que el motor de expresiones regulares no retrocede al subpatrón ((?'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, por lo que el motor de expresiones regulares retrocede al subpatrón (((?'Open'<).

10

(((?'Open'<)

Encuentra el corchete angular de apertura de "<mno>" y se lo asigna al grupo Open. Su colección Group.Captures ahora tiene un solo valor, "<".

11

[^<>]*

Encuentra "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, por lo que el motor de expresiones regulares retrocede al subpatrón (?'Open'<)[^<>]*).

13

(((?'Open'<)

Encuentra el corchete angular de apertura de "<xyz>" y se lo 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

[^<>]*

Encuentra "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, por lo que el motor de expresiones regulares no retrocede al subpatrón (?'Open'<)[^<>]*).

16

((?'Close-Open'>)

Encuentra 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 convierte en 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 que no sean corchetes 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, por lo que el motor de expresiones regulares retrocede al subpatrón ((?'Close-Open'>)[^<>]*).

19

((?'Close-Open'>)

Encuentra 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 que no sean corchetes 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, por lo que el motor de expresiones regulares no retrocede al subpatrón ((?'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, por lo que el motor de expresiones regulares no retrocede al subpatrón (((?'Open'<).

23

(?(Open)(?!))

El grupo Open no está definido, por lo que no se intenta encontrar ninguna coincidencia.

24

$

Encuentra el final de la cadena de entrada.

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

(?:subexpression)

donde subexpression es cualquier patrón 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 agrupamiento anidadas, no se aplica una construcción de grupo sin captura exterior a las construcciones de grupo anidadas interiores.

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.


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*)+\. coincide con una frase que termina en un punto. Dado que la expresión regular se centra en frases y no en palabras individuales, las construcciones de agrupamiento se usan exclusivamente como cuantificadores. El patrón de la expresión regular se interpreta como se muestra en la tabla siguiente.

Modelo

Descripción

\b

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

(?:\w+)

Coincide con uno o varios caracteres que se usan para formar palabras. No asigna el texto coincidente a un grupo capturado.

\W*

Coincide con cero o más caracteres que no se usan para formar palabras.

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

Coincide una o varias veces con el patrón de uno o varios caracteres que se usan para formar palabras comenzando por un límite de palabras, seguido de cero o más caracteres que no se usan para formar palabras. No asigna el texto coincidente a un grupo capturado.

\.

Buscar coincidencias con un punto.

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

(?imnsx-imnsx: subexpression )

donde subexpression es cualquier patrón 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 sola línea. Para obtener más información sobre las opciones insertadas que puede especificar, vea Opciones de expresiones regulares.

Nota Nota

Puede especificar opciones que se apliquen a una expresión regular completa en lugar de a una subexpresión usando un constructor de la clase System.Text.RegularExpressions.Regex o un método estático. También puede especificar opciones insertadas que se aplican después de un punto concreto en una expresión regular usando 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 capturada por subexpression 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 opciones insertadas en una construcción de agrupamiento para habilitar la coincidencia sin distinción entre mayúsculas y minúsculas y omitir el espacio en blanco del patrón para identificar todas las palabras que comienzan por la letra "d". La expresión regular se define como se muestra en la tabla siguiente.

Modelo

Descripción

\b

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

(?ix: d \w+)

Usando una coincidencia sin distinción entre mayúsculas y minúsculas y omitiendo los espacios en blanco en este patrón, busca una "d" seguida de uno o varios caracteres que se usan para formar palabras.

\s

Buscar coincidencias con un carácter que sea un espacio en blanco.


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.      


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

(?= subexpression )

donde subexpression es cualquier patrón de expresión regular. Para que se produzca una coincidencia, la cadena de entrada debe coincidir con el patrón de expresión regular de subexpression, aunque la subcadena coincidente no se incluya en el resultado de la coincidencia. Una aserción de búsqueda anticipada positiva de ancho cero no retrocede.

Normalmente, una aserción de búsqueda anticipada positiva de ancho cero se encuentra al final de un patrón 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 debe incluirse en la coincidencia. También resulta útil para evitar un retroceso excesivo. Puede usar una aserción de búsqueda anticipada positiva de ancho cero para asegurarse de que un grupo capturado determinado comienza por un texto que coincide con un subconjunto del patrón definido para dicho grupo capturado. Por ejemplo, si un grupo de captura coincide con caracteres consecutivos que se usan para formar palabras, puede usar una aserción de búsqueda anticipada positiva de ancho cero para requerir que el primero de los caracteres sea alfabético y esté en mayúsculas.

En el ejemplo siguiente se usa 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.


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

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

\w+

Coincide con uno o varios caracteres que se usan para formar palabras.

(?=\sis\b)

Determina si los caracteres que se usan para formar palabras van seguidos de un carácter de espacio en blanco y la cadena "is", seguida de un límite de palabras. En ese caso, la coincidencia es correcta.

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

(?! subexpression )

donde subexpression es cualquier patrón de expresión regular. Para que se produzca la coincidencia, la cadena de entrada no debe coincidir con el patrón de expresión regular de subexpression, aunque la cadena coincidente no se incluya 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 patrón concreto que no se debería buscar cuando el principio de la expresión regular define un patrón 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 negativa de ancho cero al principio de la expresión regular para buscar palabras que no comienzan por "un".


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

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

(?!un)

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

\w+

Coincide con uno o varios caracteres que se usan para formar palabras.

\b

Finaliza 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 negativa de ancho cero al final de la expresión regular para buscar palabras que no terminan por un carácter de puntuación.


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

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

\w+

Coincide con uno o varios caracteres que se usan para formar palabras.

\b

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

\p{P})

Si el carácter siguiente no es un signo de puntuación (como un punto o una coma), la coincidencia se realiza.

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

(?<= subexpression )

donde subexpression es cualquier patrón de expresión regular. Para que se produzca una coincidencia, subexpression debe encontrarse en la cadena de entrada a la izquierda de la posición actual, aunque subexpression no esté incluida en el resultado de la coincidencia. Una aserción de búsqueda tardía positiva de ancho cero no retrocede.

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

Por ejemplo, el ejemplo siguiente coincide 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).


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 patrón 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úa la búsqueda si los dos dígitos decimales van precedidos de los dos dígitos decimales "20" en un límite de palabra.

\b

Finaliza 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 usan 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 patrón de la expresión regular de dicho grupo. Por ejemplo, si un grupo captura todos los caracteres que se usan para formar palabras consecutivos, puede usar una aserción de búsqueda tardía positiva de ancho cero para requerir que el último carácter sea alfabético.

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

(?<! subexpression )

donde subexpression es cualquier patrón de expresión regular. Para que se produzca una coincidencia, subexpression no debe encontrarse 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 usan normalmente al principio de las expresiones regulares. El patrón 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 patrón de expresión regular de dicho grupo. Por ejemplo, si un grupo captura todos los caracteres que se usan para formar palabras consecutivos, se puede usar una aserción de búsqueda tardía positiva de ancho 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).


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 patrón 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

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

\w+

Coincide con uno o varios caracteres que se usan para formar palabras seguidos de un carácter de espacio en blanco.

\d{1,2},

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

\d{4}\b

Coincide con cuatro dígitos decimales seguidos de un límite de palabras.

(?<!(Saturday|Sunday) )

Si la coincidencia va precedida por algo distinto de las cadenas "Saturday" o "Sunday" seguidas de un espacio, la coincidencia es correcta.

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

(?> subexpression )

donde subexpression es cualquier patrón de expresión regular.

Comúnmente, si una expresión regular incluye un patrón de coincidencia opcional o alternativo y no se produce una coincidencia, el motor de expresiones regulares puede crear una bifurcación en varias direcciones para buscar coincidencias de una cadena de entrada con un patrón. 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 bifurcación e intentar la coincidencia usando la segunda bifurcación. Este proceso puede continuar hasta que se hayan probado todas las bifurcaciones.

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

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

En el ejemplo siguiente se muestra cómo una subexpresión sin retroceso modifica los resultados de una coincidencia de patrones. La expresión regular con retroceso coincide correctamente con una serie de caracteres repetidos seguidos de una o varias apariciones del mismo carácter en un límite de palabras, pero la expresión regular sin retroceso no lo hace.


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


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

Modelo

Descripción

(\w)

Coincide con un único carácter que se usa para formar palabras y se lo asigna al primer grupo de captura.

\1+

Coincide con el valor de la primera subcadena capturada una o varias veces.

.

Coincide con cualquier carácter.

\b

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

(?>(\w)\1+)

Coincide con una o varias apariciones de un carácter que se usa para formar palabras duplicado, pero no retrocede para buscar el último carácter de un límite de palabras.

Las subcadenas con las que coincide un grupo de captura de una expresión regular se representan mediante objetos System.Text.RegularExpressions.Group, que se pueden 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 con 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 en expresiones regulares).

  • 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 se aplica un cuantificador a un grupo de captura, las propiedades Capture.Value, Capture.Length e Capture.Index del objeto Group correspondiente reflejarán la última subcadena capturada por un grupo de captura. Se puede recuperar un conjunto completo de subcadenas capturadas por grupos que tienen cuantificadores desde el objeto CaptureCollection devuelto por la propiedad Group.Captures.

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


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 patrón 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

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

(\w+)

Coincide con uno o varios caracteres que se usan para formar palabras. Juntos, estos caracteres forman una palabra. Éste es el segundo grupo de captura.

\W+

Coincide con uno o varios caracteres que no se usan para formar palabras.

(\w+)\W+)+

Coincide una o varias veces con el patrón de uno o varios caracteres que se usan para formar palabras seguidos de uno o varios caracteres que no se usan para formar palabras. Éste es el primer grupo de captura.

El primer grupo de captura coincide con cada palabra de la frase. El segundo grupo de captura coincide con 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.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft