Compartir a través de

Construcciones misceláneas

  • Artículo

Las expresiones regulares de .NET Framework incluyen tres construcciones de lenguaje misceláneas. Uno permite habilitar o deshabilitar determinadas opciones de coincidencia en un modelo de expresión regular. Los dos restantes le permiten incluir comentarios en una expresión regular.

Opciones insertadas

Puede establecer o deshabilitar determinadas opciones de coincidencia de modelos para parte de una expresión regular utilizando la sintaxis

(?imnsx-imnsx)

Indique las opciones que desee habilitar después del signo de interrogación y las opciones que desee deshabilitar después del signo menos. En la siguiente tabla se describe cada una de las opciones. Para obtener más información sobre cada opción, vea Opciones de expresiones regulares.

Opción

Descripción

i

Coincidencia sin distinción entre mayúsculas y minúsculas.

m

Modo multilínea.

n

Solo capturas explícitas. (Los paréntesis no actúan como grupos de captura.)

s

Modo de una sola línea.

x

Omite el espacio en blanco sin escape y permite comentarios en modo x.

Cualquier cambio en las opciones de expresión regular definidas por la construcción (?imnsx-imnsx) permanece en vigor hasta el fin del grupo envolvente.

NotaNota

La construcción de agrupación (?imnsx-imnsx:subexpresión) proporciona una funcionalidad idéntica para una subexpresión.Para obtener más información, vea Construcciones de agrupamiento.

En el siguiente ejemplo se utilizan las opciones i, n y x para habilitar la no distinción entre mayúsculas y minúsculas y las capturas explícitas, y para omitir el espacio en blanco en el modelo de expresión regular en medio de una expresión regular.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String 
      Dim input As String = "double dare double Double a Drooling dog The Dreaded Deep"

      pattern = "\b(D\w+)\s(d\w+)\b"
      ' Match pattern using default options.
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
         If match.Groups.Count > 1 Then
            For ctr As Integer = 1 To match.Groups.Count - 1 
               Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
            Next
         End If
      Next
      Console.WriteLine()

      ' Change regular expression pattern to include options.
      pattern = "\b(D\w+)(?ixn) \s (d\w+) \b"
      ' Match new pattern with options. 
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
         If match.Groups.Count > 1 Then
            For ctr As Integer = 1 To match.Groups.Count - 1 
               Console.WriteLine("   Group {0}: '{1}'", ctr, match.Groups(ctr).Value)
            Next
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'       Drooling dog
'          Group 1: Drooling
'          Group 2: dog
'       
'       Drooling dog
'          Group 1: 'Drooling'
'       Dreaded Deep
'          Group 1: 'Dreaded'

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern; 
      string input = "double dare double Double a Drooling dog The Dreaded Deep";

      pattern = @"\b(D\w+)\s(d\w+)\b";
      // Match pattern using default options.
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine(match.Value);
         if (match.Groups.Count > 1)
            for (int ctr = 1; ctr < match.Groups.Count; ctr++) 
               Console.WriteLine("   Group {0}: {1}", ctr, match.Groups[ctr].Value);
      }
      Console.WriteLine();

      // Change regular expression pattern to include options.
      pattern = @"\b(D\w+)(?ixn) \s (d\w+) \b";
      // Match new pattern with options. 
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine(match.Value);
         if (match.Groups.Count > 1)
            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:
//       Drooling dog
//          Group 1: Drooling
//          Group 2: dog
//       
//       Drooling dog
//          Group 1: 'Drooling'
//       Dreaded Deep
//          Group 1: 'Dreaded'

En el ejemplo se definen dos expresiones regulares. El primero, \b(D\w+)\s(d\w+)\b, coincide con dos palabras consecutivas que comienzan con una "D" mayúscula y una "d" minúscula. La segunda expresión regular, \b(D\w+)(?ixn) \s (d\w+) \b, utiliza opciones alineadas para modificar este modelo, tal y como se describe en la siguiente tabla. Una comparación de los resultados confirma el efecto del constructo (?ixn).

Modelo

Descripción

\b

Empezar en un límite de palabras.

(D\w+)

Busca una coincidencia con una letra mayúscula "D" seguida de uno o varios caracteres de palabra. Este es el primer grupo de capturas.

(?ixn)

A partir de ese punto, las comparaciones se realizan sin distinción de mayúsculas y minúsculas, solo se realizan capturas explícitas y se omite el espacio en blanco en el modelo de expresión regular.

\s

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

(d\w+)

Busca una coincidencia de una letra "d" en minúscula o mayúscula seguida de uno o varios caracteres de palabra. No se captura este grupo porque la opción n (captura explícita) estaba habilitada.

\b

Hacer coincidir con un límite de palabras.

Comentario insertado

La construcción (?# comentario) le permite incluir un comentario alineado en una expresión regular. El motor de expresiones regulares no utiliza ninguna parte del comentario en la coincidencia de modelos, aunque el comentario está incluido en la cadena devuelta por el método Regex.ToString. El comentario termina en el primer paréntesis de cierre.

En el siguiente ejemplo se repite el primer modelo de expresión regular del ejemplo de la sección anterior. Agrega dos comentarios insertados a la expresión regular para indicar si la comparación distingue entre mayúsculas y minúsculas. El modelo de expresión regular, \b((?# case-sensitive comparison)D\w+)\s((?#case-insensitive comparison)d\w+)\b, se define como sigue.

Modelo

Descripción

\b

Empezar en un límite de palabras.

(?# case-sensitive comparison)

Comentario No afecta al comportamiento de coincidencia de modelos.

(D\w+)

Busca una coincidencia con una letra mayúscula "D" seguida de uno o varios caracteres de palabra. Éste es el primer grupo de captura.

\s

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

(?ixn)

A partir de ese punto, las comparaciones se realizan sin distinción de mayúsculas y minúsculas, solo se realizan capturas explícitas y se omite el espacio en blanco en el modelo de expresión regular.

(?#case-insensitive comparison)

Comentario No afecta al comportamiento de coincidencia de modelos.

(d\w+)

Busca una coincidencia de una letra "d" en minúscula o mayúscula seguida de uno o varios caracteres de palabra. Éste es el segundo grupo de capturas.

\b

Hacer coincidir con un límite de palabras.

 
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b((?# case sensitive comparison)D\w+)\s(?ixn)((?#case insensitive comparison)d\w+)\b"
      Dim rgx As New Regex(pattern)
      Dim input As String = "double dare double Double a Drooling dog The Dreaded Deep"

      Console.WriteLine("Pattern: " + pattern.ToString())
      ' Match pattern using default options.
      For Each match As Match In rgx.Matches(input)
         Console.WriteLine(match.Value)
         If match.Groups.Count > 1 Then
            For ctr As Integer = 1 To match.Groups.Count - 1 
               Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
            Next
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'    Pattern: \b((?# case sensitive comparison)D\w+)\s(?ixn)((?#case insensitive comp
'    arison)d\w+)\b
'    Drooling dog
'       Group 1: Drooling
'    Dreaded Deep
'       Group 1: Dreaded

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b((?# case sensitive comparison)D\w+)\s(?ixn)((?#case insensitive comparison)d\w+)\b";
      Regex rgx = new Regex(pattern);
      string input = "double dare double Double a Drooling dog The Dreaded Deep";

      Console.WriteLine("Pattern: " + pattern.ToString());
      // Match pattern using default options.
      foreach (Match match in rgx.Matches(input))
      {
         Console.WriteLine(match.Value);
         if (match.Groups.Count > 1)
         {
            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:
//    Pattern: \b((?# case sensitive comparison)D\w+)\s(?ixn)((?#case insensitive comp
//    arison)d\w+)\b
//    Drooling dog
//       Group 1: Drooling
//    Dreaded Deep
//       Group 1: Dreaded

Comentario de fin de línea

Una almohadilla (#) marca un comentario del modo x, que se inicia en el carácter de no escape # al final del modelo de expresión regular y continúa hasta el fin de la línea. Para utilizar esta construcción, debe habilitar la opción x (mediante opciones alineadas) o proporcionar el valor RegexOptions.IgnorePatternWhitespace al parámetro option al crear instancias del objeto Regex o llamar a un método estático Regex.

En el ejemplo siguiente se muestra la construcción de comentario de fin de línea. Determina si una cadena es una cadena de formato compuesto que incluye al menos un elemento de formato. La tabla siguiente describe las construcciones del modelo de expresión regular:

\{\d+(,-*\d+)*(\:\w{1,4}?)*\}(?x) # Looks for a composite format item.

Modelo

Descripción

\{

Busca una coincidencia de una llave de apertura.

\d+

Buscar coincidencias con uno o más dígitos decimales.

(,-*\d+)*

Busca cero o una coincidencia con un carácter de coma seguido de un signo menos opcional seguido de uno o varios dígitos decimales.

(\:\w{1,4}?)*

Busca una o varias coincidencias con un carácter de dos puntos seguido de uno a cuatro caracteres de espacio en blanco, pero limitando estos caracteres al menor número posible.

(?#case insensitive comparison)

Un comentario alineado. No afecta al comportamiento de coincidencia de modelos.

\}

Busca una coincidencia con una llave de cierre.

(?x)

Habilite la opción de omitir espacio en blanco para que se reconozca el comentario del fin de línea.

# Looks for a composite format item.

Un comentario de fin de línea.

 
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\{\d+(,-*\d+)*(\:\w{1,4}?)*\}(?x) # Looks for a composite format item."
      Dim input As String = "{0,-3:F}"
      Console.WriteLine("'{0}':", input)
      If Regex.IsMatch(input, pattern) Then
         Console.WriteLine("   contains a composite format item.")
      Else
         Console.WriteLine("   does not contain a composite format item.")
      End If
   End Sub
End Module
' The example displays the following output:
'       '{0,-3:F}':
'          contains a composite format item.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\{\d+(,-*\d+)*(\:\w{1,4}?)*\}(?x) # Looks for a composite format item.";
      string input = "{0,-3:F}";
      Console.WriteLine("'{0}':", input);
      if (Regex.IsMatch(input, pattern))
         Console.WriteLine("   contains a composite format item.");
      else
         Console.WriteLine("   does not contain a composite format item.");
   }
}
// The example displays the following output:
//       '{0,-3:F}':
//          contains a composite format item.

Observe que, en lugar de proporcionar la construcción (?x) en la expresión regular, el comentario también pudo haberse reconocido llamando al método Regex.IsMatch(String, String, RegexOptions) y pasándole el valor de enumeración RegexOptions.IgnorePatternWhitespace.

Vea también

Conceptos

Elementos del lenguaje de expresiones regulares