Construcciones misceláneas en expresiones regularesMiscellaneous Constructs in Regular Expressions

Las expresiones regulares en .NET incluyen tres construcciones de lenguaje misceláneas.Regular expressions in .NET include three miscellaneous language constructs. Una permite habilitar o deshabilitar opciones de coincidencia determinadas en medio de un patrón de expresión regular.One lets you enable or disable particular matching options in the middle of a regular expression pattern. Las otras dos permiten incluir comentarios en una expresión regular.The remaining two let you include comments in a regular expression.

Opciones insertadasInline Options

Puede establecer o deshabilitar opciones de coincidencia de patrones específicas para una parte de una expresión regular mediante la sintaxisYou can set or disable specific pattern matching options for part of a regular expression by using the syntax

(?imnsx-imnsx)

Indique las opciones que quiere habilitar después del signo de interrogación y las opciones que quiere deshabilitar después del signo menos.You list the options you want to enable after the question mark, and the options you want to disable after the minus sign. En la siguiente tabla se describe cada una de las opciones.The following table describes each option. Para obtener más información sobre cada opción, consulte Opciones de expresiones regulares.For more information about each option, see Regular Expression Options.

OpciónOption DescripciónDescription
i Coincidencia sin distinción entre mayúsculas y minúsculas.Case-insensitive matching.
m Modo multilínea.Multiline mode.
n Solo capturas explícitas.Explicit captures only. (Los paréntesis no actúan como grupos de capturas).(Parentheses do not act as capturing groups.)
s Modo de una sola línea.Single-line mode.
x Se omite el espacio en blanco sin escape y se permiten los comentarios en modo X.Ignore unescaped white space, and allow x-mode comments.

Cualquier cambio en las opciones de expresión regular definido mediante la construcción (?imnsx-imnsx) permanece en vigor hasta el final del grupo envolvente.Any change in regular expression options defined by the (?imnsx-imnsx) construct remains in effect until the end of the enclosing group.

Nota

La construcción de agrupamiento (?imnsx-imnsx:subexpresión) proporciona una funcionalidad idéntica para una subexpresión.The (?imnsx-imnsx:subexpression) grouping construct provides identical functionality for a subexpression. Para obtener más información, consulte Construcciones de agrupamiento.For more information, see Grouping Constructs.

En el ejemplo siguiente se usan las opciones i, n y x para habilitar las capturas explícitas y la opción que no hace distinción entre mayúsculas y minúsculas, y para omitir el espacio en blanco del patrón de expresión regular en medio de una expresión regular.The following example uses the i, n, and x options to enable case insensitivity and explicit captures, and to ignore white space in the regular expression pattern in the middle of a regular expression.

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'
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'

En el ejemplo se definen dos expresiones regulares.The example defines two regular expressions. La primera, \b(D\w+)\s(d\w+)\b, coincide con dos palabras consecutivas que empiezan con una "D" mayúscula y una "d" minúscula.The first, \b(D\w+)\s(d\w+)\b, matches two consecutive words that begin with an uppercase "D" and a lowercase "d". La segunda expresión regular, \b(D\w+)(?ixn) \s (d\w+) \b, usa opciones insertadas para modificar este patrón, como se describe en la tabla siguiente.The second regular expression, \b(D\w+)(?ixn) \s (d\w+) \b, uses inline options to modify this pattern, as described in the following table. Una comparación de los resultados confirma los efectos de la construcción (?ixn).A comparison of the results confirms the effect of the (?ixn) construct.

ModeloPattern DescripciónDescription
\b Empieza en un límite de palabras.Start at a word boundary.
(D\w+) Coincide con una "D" mayúscula seguida de uno o más caracteres de palabra.Match a capital "D" followed by one or more word characters. Este es el primer grupo de capturas.This is the first capture group.
(?ixn) A partir de este punto, hace comparaciones sin distinción entre mayúsculas y minúsculas, solo hace capturas explícitas y omite el espacio en blanco del patrón de expresión regular.From this point on, make comparisons case-insensitive, make only explicit captures, and ignore white space in the regular expression pattern.
\s Coincide con un carácter de espacio en blanco.Match a white-space character.
(d\w+) Coincide con una "d" mayúscula o minúscula seguida de uno o más caracteres de palabra.Match an uppercase or lowercase "d" followed by one or more word characters. Este grupo no se captura porque se ha habilitado la opción n (captura explícita).This group is not captured because the n (explicit capture) option was enabled..
\b Coincide con un límite de palabras.Match a word boundary.

Comentario alineadoInline Comment

La construcción (?# comment) permite incluir un comentario alineado en una expresión regular.The (?# comment) construct lets you include an inline comment in a regular expression. El motor de expresiones regulares no usa ninguna parte del comentario en la coincidencia de patrones, aunque el comentario se incluye en la cadena devuelta por el método Regex.ToString.The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. El comentario termina en el primer paréntesis de cierre.The comment ends at the first closing parenthesis.

En el ejemplo siguiente se repite el primer patrón de expresión regular del ejemplo de la sección anterior.The following example repeats the first regular expression pattern from the example in the previous section. Se agregan dos comentarios alineados en la expresión regular para indicar si la comparación distingue entre mayúsculas y minúsculas.It adds two inline comments to the regular expression to indicate whether the comparison is case-sensitive. El patrón de expresión regular, \b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comparison)d\w+)\b, se define como se indica a continuación.The regular expression pattern, \b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comparison)d\w+)\b, is defined as follows.

ModeloPattern DescripciónDescription
\b Empieza en un límite de palabras.Start at a word boundary.
(?# case-sensitive comparison) Comentario.A comment. No afecta al comportamiento de la coincidencia de patrones.It does not affect pattern-matching behavior.
(D\w+) Coincide con una "D" mayúscula seguida de uno o más caracteres de palabra.Match a capital "D" followed by one or more word characters. Este es el primer grupo de captura.This is the first capturing group.
\s Coincide con un carácter de espacio en blanco.Match a white-space character.
(?ixn) A partir de este punto, hace comparaciones sin distinción entre mayúsculas y minúsculas, solo hace capturas explícitas y omite el espacio en blanco del patrón de expresión regular.From this point on, make comparisons case-insensitive, make only explicit captures, and ignore white space in the regular expression pattern.
(?#case-insensitive comparison) Comentario.A comment. No afecta al comportamiento de la coincidencia de patrones.It does not affect pattern-matching behavior.
(d\w+) Coincide con una "d" mayúscula o minúscula seguida de uno o más caracteres de palabra.Match an uppercase or lowercase "d" followed by one or more word characters. Este es el segundo grupo de capturas.This is the second capture group.
\b Coincide con un límite de palabras.Match a word boundary.
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
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

Comentario de final de líneaEnd-of-Line Comment

Un signo de número (#) marca un comentario en modo X, que empieza en el carácter # sin escape al final del patrón de expresión regular y continúa hasta el final de la línea.A number sign (#)marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. Para usar esta construcción, debe habilitar la opción x (mediante opciones insertadas) o proporcionar el valor RegexOptions.IgnorePatternWhitespace al parámetro option al crear una instancia del objeto Regex o al llamar al método Regex estático.To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method.

En el ejemplo siguiente se muestra la construcción de comentario de final de línea.The following example illustrates the end-of-line comment construct. Determina si una cadena es una cadena de formato compuesto que incluye al menos un elemento de formato.It determines whether a string is a composite format string that includes at least one format item. En la tabla siguiente se describe la construcción en el patrón de expresión regular:The following table describes the constructs in the regular expression pattern:

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

ModeloPattern DescripciónDescription
\{ Coincide con una llave de apertura.Match an opening brace.
\d+ Buscar coincidencias con uno o más dígitos decimales.Match one or more decimal digits.
(,-*\d+)* Coincide con cero o una aparición de una coma seguida de un signo menos opcional, seguido de uno o más dígitos decimales.Match zero or one occurrence of a comma, followed by an optional minus sign, followed by one or more decimal digits.
(\:\w{1,4}?)* Coincide con cero o una aparición de un signo de dos puntos seguido de uno a cuatro caracteres de espacio en blanco, pero el menor número posible.Match zero or one occurrence of a colon, followed by one to four, but as few as possible, white-space characters.
\} Coincide con una llave de cierre.Match a closing brace.
(?x) Habilita la opción de ignorar el espacio en blanco del patrón para que se reconozca el comentario de final de línea.Enable the ignore pattern white-space option so that the end-of-line comment will be recognized.
# Looks for a composite format item. Comentario de final de línea.An end-of-line comment.
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.
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.

Tenga en cuenta que, en lugar de proporcionar la construcción (?x) en la expresión regular, el comentario también podía haberse reconocido llamando al método Regex.IsMatch(String, String, RegexOptions) y pasando el valor de enumeración RegexOptions.IgnorePatternWhitespace.Note that, instead of providing the (?x) construct in the regular expression, the comment could also have been recognized by calling the Regex.IsMatch(String, String, RegexOptions) method and passing it the RegexOptions.IgnorePatternWhitespace enumeration value.

Vea tambiénSee also