Opciones de expresiones regulares
De forma predeterminada, la comparación de una cadena de entrada con cualquier carácter literal en un modelo de expresión regular distingue entre mayúsculas y minúsculas, el espacio en blanco en un modelo de expresión regular se interpreta como caracteres de espacio en blanco literales y a los grupos de captura de una expresión regular se les asignan nombres tanto implícita como explícitamente. Puede modificar éstos y muchos otros aspectos del comportamiento de una expresión regular predeterminada especificando las opciones de expresión regular. Estas opciones, que se muestran en la siguiente tabla, pueden estar incluidas alineadas como parte del modelo de expresión regular o pueden proporcionarse a un constructor de clase System.Text.RegularExpressions.Regex o método de coincidencia de modelos estático como un valor de enumeración System.Text.RegularExpressions.RegexOptions.
Miembro RegexOptions |
Carácter en línea |
Efecto |
|---|---|---|
No está disponible |
Use el comportamiento predeterminado. Para obtener más información, vea Opciones predeterminadas. |
|
i |
Use la coincidencia sin distinción entre mayúsculas y minúsculas. Para obtener más información, vea Coincidencia sin distinción entre mayúsculas y minúsculas. |
|
m |
Use el modo multilínea, donde ^ y $ coinciden al principio y al final de cada línea (no justo al principio y al final de la cadena de entrada). Para obtener más información, vea Modo multilínea. |
|
s |
Utilice el modo de una línea, donde el punto (.) coincide con todos los caracteres (en lugar de hacerlo con todos los caracteres excepto \n). Para obtener más información, vea Modo de una sola línea. |
|
n |
No capture grupos sin nombre. Solo las capturas válidas son explícitamente grupos con nombre o número con la forma (?<nombre> subexpresión). Para obtener más información, vea Solo capturas explícitas. |
|
No está disponible |
Compile la expresión regular en un ensamblado. Para obtener más información, vea Expresiones regulares compiladas. |
|
x |
Excluye el espacio en blanco sin escape del modelo y habilita los comentarios después de una almohadilla (#). Para obtener más información, vea Omitir espacio en blanco. |
|
No está disponible |
Cambiar la dirección de búsqueda. La búsqueda se desplaza de derecha a izquierda en vez de izquierda a derecha. Para obtener más información, vea Modo de derecha a izquierda. |
|
No está disponible |
Habilita el comportamiento conforme a ECMAScript para esta expresión. Para obtener más información, vea Comportamiento del motor de búsqueda de coincidencias ECMAScript. |
|
No está disponible |
Ignore las diferencias culturales de idioma. Para obtener más información, vea Comparación usando la referencia cultural de todos los idiomas. |
Especificar las opciones
Puede especificar opciones para expresiones regulares de una de las tres maneras siguientes:
En el parámetro options de un constructor de clase System.Text.RegularExpressions.Regex o método de coincidencia de modelos de estático (Shared en Visual Basic), como Regex.Regex(String, RegexOptions) o Regex.Match(String, String, RegexOptions). El parámetro options es una combinación OR bit a bit de los valores enumerados de System.Text.RegularExpressions.RegexOptions.
Esto se muestra en el ejemplo siguiente. Usa el parámetro options del método Regex.Match(String, String, RegexOptions) para habilitar la concordancia sin distinción entre mayúsculas y minúsculas e ignorar el espacio en blanco del modelo al identificar palabras que comienzan por la letra "d."
Dim pattern As String = "d \w+ \s" Dim input As String = "Dogs are decidedly good pets." Dim options As RegexOptions = RegexOptions.IgnoreCase Or RegexOptions.IgnorePatternWhitespace For Each match As Match In Regex.Matches(input, pattern, options) 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 = @"d \w+ \s"; string input = "Dogs are decidedly good pets."; RegexOptions options = RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace; foreach (Match match in Regex.Matches(input, pattern, options)) 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.Aplicando las opciones alineadas en un modelo de expresión regular con la sintaxis (?imnsx-imnsx). La opción se aplica al modelo a partir del punto que la opción está definida hasta los extremos del modelo o hasta el punto en el que la opción no está definida por otra opción alineada. Para obtener más información, vea el tema Construcciones misceláneas.
Esto se muestra en el ejemplo siguiente. Usa opciones alineadas para habilitar la concordancia sin distinción entre mayúsculas y minúsculas e ignorar el espacio en blanco del modelo al identificar palabras que comienzan por la letra "d."
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 = @"(?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.Aplicando las opciones alineadas en una construcción de agrupación determinada en un modelo de expresión regular con la sintaxis (?imnsx-imnsx:subexpresión). Si no hay signo delante de un conjunto de opciones, el conjunto se activa; si hay un signo menos delante de un conjunto de opciones, el conjunto se desactiva. (? es una parte fija de la sintaxis de construcción de lenguaje que se requiere si las opciones están habilitadas o deshabilitadas.) La opción sólo se aplica a ese grupo. Para obtener más información, vea Construcciones de agrupamiento.
Esto se muestra en el ejemplo siguiente. Usa opciones alineadas en una construcción de agrupación para habilitar la concordancia sin distinción entre mayúsculas y minúsculas e ignorar el espacio en blanco del modelo al identificar palabras que comienzan por la letra "d."
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.
Si las opciones están especificadas alineadas, un signo menos (-) delante de una opción o conjunto de opciones desactiva las opciones. Por ejemplo, la construcción en línea (?ix-ms) activa las opciones RegexOptions.IgnoreCase y RegexOptions.IgnorePatternWhitespace y desactiva las opciones RegexOptions.Multiline y RegexOptions.Singleline. De forma predeterminada, todas las opciones de expresiones regulares están desactivadas.
.gif "Nota") Nota |
|---|
Si las opciones de expresión regular especificadas en el parámetro options de un constructor o llamada al método entran en conflicto con las opciones alineadas especificadas en un modelo de expresión regular, se usan las opciones alineadas. |
Las siguientes cinco opciones de expresión regular se pueden establecer con el parámetro de opciones y alineado:
Las siguientes cinco opciones de expresión regular se pueden establecer mediante el parámetro options pero no se pueden establecer con alineado:
Determinar las opciones
Puede determinar qué opciones se proporcionaron a un objeto Regex cuando se crea una instancia mediante la recuperación del valor de la propiedad de solo lectura Regex.Options. Esta propiedad es particularmente útil para determinar las opciones que se definen para una expresión regular de compilación creadas por el método Regex.CompileToAssembly.
Para comprobar la presencia de cualquier opción salvo RegexOptions.None, realice una operación AND con el valor de la propiedad Regex.Options y el valor RegexOptions en que se está interesado. Después prueba si el resultado es igual que el valor RegexOptions. En el siguiente ejemplo se comprueba si se ha establecido la opción RegexOptions.IgnoreCase.
If (rgx.Options And RegexOptions.IgnoreCase) = RegexOptions.IgnoreCase Then
Console.WriteLine("Case-insensitive pattern comparison.")
Else
Console.WriteLine("Case-sensitive pattern comparison.")
End If
if ((rgx.Options & RegexOptions.IgnoreCase) == RegexOptions.IgnoreCase)
Console.WriteLine("Case-insensitive pattern comparison.");
else
Console.WriteLine("Case-sensitive pattern comparison.");
Para probar RegexOptions.None, determine si el valor de la propiedad Regex.Options es igual a RegexOptions.None, como se muestra en el ejemplo siguiente.
If rgx.Options = RegexOptions.None Then
Console.WriteLine("No options have been set.")
End If
if (rgx.Options == RegexOptions.None)
Console.WriteLine("No options have been set.");
En las secciones siguientes se enumeran las opciones admitidas en las expresiones regulares de .NET Framework.
Opciones predeterminadas
La opción RegexOptions.None indica que no se ha especificado ninguna opción y que el motor de expresiones regulares utiliza su comportamiento predeterminado. Entre estas estructuras se incluyen las siguientes:
El modelo se interpreta como un canónico en lugar de como una expresión regular de ECMAScript.
Se hace coincidir con el modelo de expresión regular en la cadena de entrada de izquierda a derecha.
Las comparaciones distinguen mayúsculas de minúsculas.
Los elementos del lenguaje $ y ^ coinciden con el comienzo y el final de la cadena de entrada.
El elemento del lenguaje . coincide con cada carácter excepto \n.
Cualquier espacio en blanco en un modelo de expresión regular se interpreta como un carácter de espacio en blanco literal.
Se utilizan las convenciones de la referencia cultural actual al comparar el modelo con la cadena de entrada.
Los grupos de captura del modelo de expresión regular son implícitos y explícitos.
| Nota |
|---|
La opción RegexOptions.None no tiene equivalente alineado.Cuando las opciones de expresión regular se aplican alineadas, el comportamiento predeterminado se restaura opción por opción, desactivando una opción determinada.Por ejemplo, (?i) activa la comparación sin distinción entre mayúsculas y minúsculas y (?-i) restaura la comparación predeterminada de distinción entre mayúsculas y minúsculas. |
Dado que la opción RegexOptions.None representa el comportamiento predeterminado del motor de expresiones regulares, raramente se especifica explícitamente en una llamada al método. En su lugar se llama a un constructor o método de coincidencia de modelos estático sin un parámetro options.
Volver al principio
Coincidencia sin distinción entre mayúsculas y minúsculas
La opción IgnoreCase, o la opción alineada i, proporciona concordancia sin distinción entre mayúsculas y minúsculas. De forma predeterminada, se usan las convenciones de uso de mayúsculas de la referencia cultural actual.
En el siguiente ejemplo se define un modelo de expresión regular, \bthe\w*\b, que coincide con todas las palabras que empiezan con "the". Dado que la primera llamada al método Match usa la comparación predeterminada de distinción entre mayúsculas y minúsculas, el resultado indica que la cadena "The" con la que comienza la frase no coincide. Coincide cuando se llama al método Match con las opciones establecidas en IgnoreCase.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\bthe\w*\b"
Dim input As String = "The man then told them about that event."
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
Next
Console.WriteLine()
For Each match As Match In Regex.Matches(input, pattern, _
RegexOptions.IgnoreCase)
Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
Next
End Sub
End Module
' The example displays the following output:
' Found then at index 8.
' Found them at index 18.
'
' Found The at index 0.
' Found then at index 8.
' Found them at index 18.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\bthe\w*\b";
string input = "The man then told them about that event.";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);
Console.WriteLine();
foreach (Match match in Regex.Matches(input, pattern,
RegexOptions.IgnoreCase))
Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);
}
}
// The example displays the following output:
// Found then at index 8.
// Found them at index 18.
//
// Found The at index 0.
// Found then at index 8.
// Found them at index 18.
En el siguiente ejemplo se modifica el modelo de expresión regular del ejemplo anterior para utilizar opciones alineadas en lugar del parámetro options y así proporcionar una comparación sin distinción entre mayúsculas y minúsculas. El primer modelo define la opción sin distinción entre mayúsculas y minúsculas en una construcción de agrupación que sólo se aplica a la letra "t" de la cadena "the." Dado que la construcción de la opción se produce al principio del modelo, el segundo modelo aplica la opción sin distinción entre mayúsculas y minúsculas a la expresión regular completa.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b(?i:t)he\w*\b"
Dim input As String = "The man then told them about that event."
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
Next
Console.WriteLine()
pattern = "(?i)\bthe\w*\b"
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
Next
End Sub
End Module
' The example displays the following output:
' Found The at index 0.
' Found then at index 8.
' Found them at index 18.
'
' Found The at index 0.
' Found then at index 8.
' Found them at index 18.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b(?i:t)he\w*\b";
string input = "The man then told them about that event.";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);
Console.WriteLine();
pattern = @"(?i)\bthe\w*\b";
foreach (Match match in Regex.Matches(input, pattern,
RegexOptions.IgnoreCase))
Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);
}
}
// The example displays the following output:
// Found The at index 0.
// Found then at index 8.
// Found them at index 18.
//
// Found The at index 0.
// Found then at index 8.
// Found them at index 18.
Volver al principio
Modo multilínea
La opción RegexOptions.Multiline, o la opción alineada m, permite al motor de expresiones regulares controlar una cadena de entrada compuesta de varias líneas. Cambia la interpretación de los elementos del lenguaje ^ y $ de manera que coincidan al principio y al final de una línea y no justo al principio y al final de la cadena de entrada.
De forma predeterminada, $ coincide solo el final de la cadena de entrada. Si especifica la opción RegexOptions.Multiline, coincide con el carácter de nueva línea (\n) o con el fin de la cadena de entrada. Sin embargo, no coincide con la combinación de caracteres de retorno de carro/salto de línea. Para que coincidan correctamente, use la subexpresión \r?$ en lugar de sólo $.
En el siguiente ejemplo se extraen los nombres y puntuaciones de los jugadores, y los agrega a una colección SortedList<TKey, TValue> que los ordena en orden descendente. Se llama al método Matches dos veces. En la primera llamada al método, la expresión regular es ^(\w+)\s(\d+)$ y no se establece ninguna opción. Como se muestra en el resultado, como el motor de expresiones regulares no puede coincidir con el modelo de entrada junto con el principio y fin de la cadena de entrada, no se encuentra ninguna coincidencia. En la segunda llamada al método, la expresión regular se cambia a ^(\w+)\s(\d+)\r?$ y las opciones se establecen en RegexOptions.Multiline. Como se muestra en el resultado, los nombres y puntuaciones coinciden correctamente y las puntuaciones se muestran en orden descendente.
Imports System.Collections.Generic
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim scores As New SortedList(Of Integer, String)(New DescendingComparer(Of Integer)())
Dim input As String = "Joe 164" + vbCrLf + _
"Sam 208" + vbCrLf + _
"Allison 211" + vbCrLf + _
"Gwen 171" + vbCrLf
Dim pattern As String = "^(\w+)\s(\d+)$"
Dim matched As Boolean = False
Console.WriteLine("Without Multiline option:")
For Each match As Match In Regex.Matches(input, pattern)
scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
matched = True
Next
If Not matched Then Console.WriteLine(" No matches.")
Console.WriteLine()
' Redefine pattern to handle multiple lines.
pattern = "^(\w+)\s(\d+)\r*$"
Console.WriteLine("With multiline option:")
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.Multiline)
scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
Next
' List scores in descending order.
For Each score As KeyValuePair(Of Integer, String) In scores
Console.WriteLine("{0}: {1}", score.Value, score.Key)
Next
End Sub
End Module
Public Class DescendingComparer(Of T) : Implements IComparer(Of T)
Public Function Compare(x As T, y As T) As Integer _
Implements IComparer(Of T).Compare
Return Comparer(Of T).Default.Compare(x, y) * -1
End Function
End Class
' The example displays the following output:
' Without Multiline option:
' No matches.
'
' With multiline option:
' Allison: 211
' Sam: 208
' Gwen: 171
' Joe: 164
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
SortedList<int, string> scores = new SortedList<int, string>(new DescendingComparer<int>());
string input = "Joe 164\n" +
"Sam 208\n" +
"Allison 211\n" +
"Gwen 171\n";
string pattern = @"^(\w+)\s(\d+)$";
bool matched = false;
Console.WriteLine("Without Multiline option:");
foreach (Match match in Regex.Matches(input, pattern))
{
scores.Add(Int32.Parse(match.Groups[2].Value), (string) match.Groups[1].Value);
matched = true;
}
if (! matched)
Console.WriteLine(" No matches.");
Console.WriteLine();
// Redefine pattern to handle multiple lines.
pattern = @"^(\w+)\s(\d+)\r*$";
Console.WriteLine("With multiline option:");
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Multiline))
scores.Add(Int32.Parse(match.Groups[2].Value), (string) match.Groups[1].Value);
// List scores in descending order.
foreach (KeyValuePair<int, string> score in scores)
Console.WriteLine("{0}: {1}", score.Value, score.Key);
}
}
public class DescendingComparer<T> : IComparer<T>
{
public int Compare(T x, T y)
{
return Comparer<T>.Default.Compare(x, y) * -1;
}
}
// The example displays the following output:
// Without Multiline option:
// No matches.
//
// With multiline option:
// Allison: 211
// Sam: 208
// Gwen: 171
// Joe: 164
El modelo de expresión regular ^(\w+)\s(\d+)\r*$ se define como se muestra en la tabla siguiente.
Modelo |
Descripción |
|---|---|
^ |
Comenzar la búsqueda al principio de la línea. |
(\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. |
(\d+) |
Buscar coincidencias con uno o más dígitos decimales. Éste es el segundo grupo de captura. |
\r? |
Buscar una coincidencia con cero o un carácter de retorno de carro. |
$ |
Final de la línea. |
El siguiente ejemplo es equivalente al anterior, salvo en que usa la opción alineada (?m) para establecer la opción de varias línea.
Imports System.Collections.Generic
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim scores As New SortedList(Of Integer, String)(New DescendingComparer(Of Integer)())
Dim input As String = "Joe 164" + vbCrLf + _
"Sam 208" + vbCrLf + _
"Allison 211" + vbCrLf + _
"Gwen 171" + vbCrLf
Dim pattern As String = "(?m)^(\w+)\s(\d+)\r*$"
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.Multiline)
scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
Next
' List scores in descending order.
For Each score As KeyValuePair(Of Integer, String) In scores
Console.WriteLine("{0}: {1}", score.Value, score.Key)
Next
End Sub
End Module
Public Class DescendingComparer(Of T) : Implements IComparer(Of T)
Public Function Compare(x As T, y As T) As Integer _
Implements IComparer(Of T).Compare
Return Comparer(Of T).Default.Compare(x, y) * -1
End Function
End Class
' The example displays the following output:
' Allison: 211
' Sam: 208
' Gwen: 171
' Joe: 164
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
SortedList<int, string> scores = new SortedList<int, string>(new DescendingComparer<int>());
string input = "Joe 164\n" +
"Sam 208\n" +
"Allison 211\n" +
"Gwen 171\n";
string pattern = @"(?m)^(\w+)\s(\d+)\r*$";
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Multiline))
scores.Add(Convert.ToInt32(match.Groups[2].Value), match.Groups[1].Value);
// List scores in descending order.
foreach (KeyValuePair<int, string> score in scores)
Console.WriteLine("{0}: {1}", score.Value, score.Key);
}
}
public class DescendingComparer<T> : IComparer<T>
{
public int Compare(T x, T y)
{
return Comparer<T>.Default.Compare(x, y) * -1;
}
}
// The example displays the following output:
// Allison: 211
// Sam: 208
// Gwen: 171
// Joe: 164
Volver al principio
Modo de una sola línea
La opción RegexOptions.Singleline, o la opción alineada s, provoca que el motor de expresiones regulares trate a la cadena de entrada como si constara de una sola línea. Hace esto cambiando el comportamiento del elemento del lenguaje de punto (.) para que coincida con cada carácter, en lugar de coincidir con cada carácter salvo con el carácter de nueva línea \n o \u000A.
En el siguiente ejemplo se muestra cómo el comportamiento del elemento del lenguaje . cambia al utilizar la opción RegexOptions.Singleline. La expresión regular ^.+ comienza en el principio de la cadena y coincide con cada carácter. De forma predeterminada, la coincidencia finaliza al final de la primera línea; el modelo de expresión regular coincide con el carácter de retorno de carro, \r o \u000D, pero no coincide con \n. Dado que la opción RegexOptions.Singleline interpreta la cadena de entrada completa como una línea única, coincide con cada carácter de la cadena de entrada, incluido \n.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "^.+"
Dim input As String = "This is one line and" + vbCrLf + "this is the second."
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(Regex.Escape(match.Value))
Next
Console.WriteLine()
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.SingleLine)
Console.WriteLine(Regex.Escape(match.Value))
Next
End Sub
End Module
' The example displays the following output:
' This\ is\ one\ line\ and\r
'
' This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = "^.+";
string input = "This is one line and" + Environment.NewLine + "this is the second.";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(Regex.Escape(match.Value));
Console.WriteLine();
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Singleline))
Console.WriteLine(Regex.Escape(match.Value));
}
}
// The example displays the following output:
// This\ is\ one\ line\ and\r
//
// This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
El siguiente ejemplo es equivalente al anterior, salvo en que usa la opción alineada (?s) para habilitar el modo de una sola línea.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "(?s)^.+"
Dim input As String = "This is one line and" + vbCrLf + "this is the second."
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(Regex.Escape(match.Value))
Next
End Sub
End Module
' The example displays the following output:
' This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = "(?s)^.+";
string input = "This is one line and" + Environment.NewLine + "this is the second.";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(Regex.Escape(match.Value));
}
}
// The example displays the following output:
// This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
Volver al principio
Solo capturas explícitas
De forma predeterminada, los grupos de captura se definen mediante el uso de paréntesis en el modelo de expresión regular. A los grupos con nombre, la opción de lenguaje (?<nombre> subexpresión) les asigna un nombre o un número, mientras que los grupos sin nombre son accesibles por índice. En el objeto GroupCollection, los grupos sin nombre preceden a los grupos con nombre.
Las construcciones de agrupamiento se usan a menudo solo para aplicar cuantificadores a varios elementos del lenguaje y las subcadenas capturadas no tienen interés. Por ejemplo, si la siguiente expresión regular:
\b\(?((\w+),?\s?)+[\.!?]\)?
está diseñado solo para extraer frases de un documento que finalizan con un punto, un signo de exclamación o un signo de interrogación; solo la frase resultante (que se representa con el objeto Match) es de interés. No son las palabras individuales en la colección.
Los grupos de captura que no se usan posteriormente pueden ser caros, porque el motor de expresiones regulares debe rellenar objetos de las colecciones CaptureCollection y GroupCollection. Alternativamente, puede usar la opción RegexOptions.ExplicitCapture u opción insertada n para especificar que las únicas capturas válidas son explícitamente grupos con nombre o numerados designados por la construcción (?<nombre> subexpresión).
El ejemplo siguiente muestra información sobre las coincidencias devueltas por el modelo de expresión regular \b\(?((\w+),?\s?)+[\.!?]\)? cuando se llama al método Match con y sin la opción RegexOptions.ExplicitCapture. Como se muestra en el resultado de la primera llamada al método, el motor de expresiones regulares rellena totalmente los objetos de colección GroupCollection y CaptureCollection con información sobre las subcadenas capturadas. Dado que se llama al segundo método con options establecido en RegexOptions.ExplicitCapture, no captura información sobre grupos.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "This is the first sentence. Is it the beginning " + _
"of a literary masterpiece? I think not. Instead, " + _
"it is a nonsensical paragraph."
Dim pattern As String = "\b\(?((?>\w+),?\s?)+[\.!?]\)?"
Console.WriteLine("With implicit captures:")
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("The match: {0}", match.Value)
Dim groupCtr As Integer = 0
For Each group As Group In match.Groups
Console.WriteLine(" Group {0}: {1}", groupCtr, group.Value)
groupCtr += 1
Dim captureCtr As Integer = 0
For Each capture As Capture In group.Captures
Console.WriteLine(" Capture {0}: {1}", captureCtr, capture.Value)
captureCtr += 1
Next
Next
Next
Console.WriteLine()
Console.WriteLine("With explicit captures only:")
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.ExplicitCapture)
Console.WriteLine("The match: {0}", match.Value)
Dim groupCtr As Integer = 0
For Each group As Group In match.Groups
Console.WriteLine(" Group {0}: {1}", groupCtr, group.Value)
groupCtr += 1
Dim captureCtr As Integer = 0
For Each capture As Capture In group.Captures
Console.WriteLine(" Capture {0}: {1}", captureCtr, capture.Value)
captureCtr += 1
Next
Next
Next
End Sub
End Module
' The example displays the following output:
' With implicit captures:
' The match: This is the first sentence.
' Group 0: This is the first sentence.
' Capture 0: This is the first sentence.
' Group 1: sentence
' Capture 0: This
' Capture 1: is
' Capture 2: the
' Capture 3: first
' Capture 4: sentence
' Group 2: sentence
' Capture 0: This
' Capture 1: is
' Capture 2: the
' Capture 3: first
' Capture 4: sentence
' The match: Is it the beginning of a literary masterpiece?
' Group 0: Is it the beginning of a literary masterpiece?
' Capture 0: Is it the beginning of a literary masterpiece?
' Group 1: masterpiece
' Capture 0: Is
' Capture 1: it
' Capture 2: the
' Capture 3: beginning
' Capture 4: of
' Capture 5: a
' Capture 6: literary
' Capture 7: masterpiece
' Group 2: masterpiece
' Capture 0: Is
' Capture 1: it
' Capture 2: the
' Capture 3: beginning
' Capture 4: of
' Capture 5: a
' Capture 6: literary
' Capture 7: masterpiece
' The match: I think not.
' Group 0: I think not.
' Capture 0: I think not.
' Group 1: not
' Capture 0: I
' Capture 1: think
' Capture 2: not
' Group 2: not
' Capture 0: I
' Capture 1: think
' Capture 2: not
' The match: Instead, it is a nonsensical paragraph.
' Group 0: Instead, it is a nonsensical paragraph.
' Capture 0: Instead, it is a nonsensical paragraph.
' Group 1: paragraph
' Capture 0: Instead,
' Capture 1: it
' Capture 2: is
' Capture 3: a
' Capture 4: nonsensical
' Capture 5: paragraph
' Group 2: paragraph
' Capture 0: Instead
' Capture 1: it
' Capture 2: is
' Capture 3: a
' Capture 4: nonsensical
' Capture 5: paragraph
'
' With explicit captures only:
' The match: This is the first sentence.
' Group 0: This is the first sentence.
' Capture 0: This is the first sentence.
' The match: Is it the beginning of a literary masterpiece?
' Group 0: Is it the beginning of a literary masterpiece?
' Capture 0: Is it the beginning of a literary masterpiece?
' The match: I think not.
' Group 0: I think not.
' Capture 0: I think not.
' The match: Instead, it is a nonsensical paragraph.
' Group 0: Instead, it is a nonsensical paragraph.
' Capture 0: Instead, it is a nonsensical paragraph.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "This is the first sentence. Is it the beginning " +
"of a literary masterpiece? I think not. Instead, " +
"it is a nonsensical paragraph.";
string pattern = @"\b\(?((?>\w+),?\s?)+[\.!?]\)?";
Console.WriteLine("With implicit captures:");
foreach (Match match in Regex.Matches(input, pattern))
{
Console.WriteLine("The match: {0}", match.Value);
int groupCtr = 0;
foreach (Group group in match.Groups)
{
Console.WriteLine(" Group {0}: {1}", groupCtr, group.Value);
groupCtr++;
int captureCtr = 0;
foreach (Capture capture in group.Captures)
{
Console.WriteLine(" Capture {0}: {1}", captureCtr, capture.Value);
captureCtr++;
}
}
}
Console.WriteLine();
Console.WriteLine("With explicit captures only:");
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.ExplicitCapture))
{
Console.WriteLine("The match: {0}", match.Value);
int groupCtr = 0;
foreach (Group group in match.Groups)
{
Console.WriteLine(" Group {0}: {1}", groupCtr, group.Value);
groupCtr++;
int captureCtr = 0;
foreach (Capture capture in group.Captures)
{
Console.WriteLine(" Capture {0}: {1}", captureCtr, capture.Value);
captureCtr++;
}
}
}
}
}
// The example displays the following output:
// With implicit captures:
// The match: This is the first sentence.
// Group 0: This is the first sentence.
// Capture 0: This is the first sentence.
// Group 1: sentence
// Capture 0: This
// Capture 1: is
// Capture 2: the
// Capture 3: first
// Capture 4: sentence
// Group 2: sentence
// Capture 0: This
// Capture 1: is
// Capture 2: the
// Capture 3: first
// Capture 4: sentence
// The match: Is it the beginning of a literary masterpiece?
// Group 0: Is it the beginning of a literary masterpiece?
// Capture 0: Is it the beginning of a literary masterpiece?
// Group 1: masterpiece
// Capture 0: Is
// Capture 1: it
// Capture 2: the
// Capture 3: beginning
// Capture 4: of
// Capture 5: a
// Capture 6: literary
// Capture 7: masterpiece
// Group 2: masterpiece
// Capture 0: Is
// Capture 1: it
// Capture 2: the
// Capture 3: beginning
// Capture 4: of
// Capture 5: a
// Capture 6: literary
// Capture 7: masterpiece
// The match: I think not.
// Group 0: I think not.
// Capture 0: I think not.
// Group 1: not
// Capture 0: I
// Capture 1: think
// Capture 2: not
// Group 2: not
// Capture 0: I
// Capture 1: think
// Capture 2: not
// The match: Instead, it is a nonsensical paragraph.
// Group 0: Instead, it is a nonsensical paragraph.
// Capture 0: Instead, it is a nonsensical paragraph.
// Group 1: paragraph
// Capture 0: Instead,
// Capture 1: it
// Capture 2: is
// Capture 3: a
// Capture 4: nonsensical
// Capture 5: paragraph
// Group 2: paragraph
// Capture 0: Instead
// Capture 1: it
// Capture 2: is
// Capture 3: a
// Capture 4: nonsensical
// Capture 5: paragraph
//
// With explicit captures only:
// The match: This is the first sentence.
// Group 0: This is the first sentence.
// Capture 0: This is the first sentence.
// The match: Is it the beginning of a literary masterpiece?
// Group 0: Is it the beginning of a literary masterpiece?
// Capture 0: Is it the beginning of a literary masterpiece?
// The match: I think not.
// Group 0: I think not.
// Capture 0: I think not.
// The match: Instead, it is a nonsensical paragraph.
// Group 0: Instead, it is a nonsensical paragraph.
// Capture 0: Instead, it is a nonsensical paragraph.
El modelo de expresión regular \b\(?((?>\w+),?\s?)+[\.!?]\)? se define como se muestra en la tabla siguiente.
Modelo |
Descripción |
|---|---|
\b |
Empezar en un límite de palabras. |
\(? |
Busca cero o una coincidencia con el paréntesis de apertura ("("). |
(?>\w+),? |
Buscar una coincidencia de cero o más caracteres, seguidos de una o ninguna coma. No retroceda cuando haya caracteres de palabra coincidentes. |
\s? |
Busca cero o una coincidencia con un carácter de espacio en blanco. |
((\w+),? \s?)+ |
Busca la combinación de uno varios caracteres de palabra, una o ninguna coma y cero o un carácter de espacio en blanco. |
[\.!?]\)? |
Buscar una coincidencia con cualquiera de los tres símbolos de la puntuación, seguidos de cero o un paréntesis del cierre (")"). |
También puede usar el elemento (?n) alineado para suprimir las capturas automáticas. En el ejemplo siguiente se modifica el modelo de expresión regular anterior para usar el elemento alineado (?n) en lugar de la opción RegexOptions.ExplicitCapture.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "This is the first sentence. Is it the beginning " + _
"of a literary masterpiece? I think not. Instead, " + _
"it is a nonsensical paragraph."
Dim pattern As String = "(?n)\b\(?((?>\w+),?\s?)+[\.!?]\)?"
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("The match: {0}", match.Value)
Dim groupCtr As Integer = 0
For Each group As Group In match.Groups
Console.WriteLine(" Group {0}: {1}", groupCtr, group.Value)
groupCtr += 1
Dim captureCtr As Integer = 0
For Each capture As Capture In group.Captures
Console.WriteLine(" Capture {0}: {1}", captureCtr, capture.Value)
captureCtr += 1
Next
Next
Next
End Sub
End Module
' The example displays the following output:
' The match: This is the first sentence.
' Group 0: This is the first sentence.
' Capture 0: This is the first sentence.
' The match: Is it the beginning of a literary masterpiece?
' Group 0: Is it the beginning of a literary masterpiece?
' Capture 0: Is it the beginning of a literary masterpiece?
' The match: I think not.
' Group 0: I think not.
' Capture 0: I think not.
' The match: Instead, it is a nonsensical paragraph.
' Group 0: Instead, it is a nonsensical paragraph.
' Capture 0: Instead, it is a nonsensical paragraph.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "This is the first sentence. Is it the beginning " +
"of a literary masterpiece? I think not. Instead, " +
"it is a nonsensical paragraph.";
string pattern = @"(?n)\b\(?((?>\w+),?\s?)+[\.!?]\)?";
foreach (Match match in Regex.Matches(input, pattern))
{
Console.WriteLine("The match: {0}", match.Value);
int groupCtr = 0;
foreach (Group group in match.Groups)
{
Console.WriteLine(" Group {0}: {1}", groupCtr, group.Value);
groupCtr++;
int captureCtr = 0;
foreach (Capture capture in group.Captures)
{
Console.WriteLine(" Capture {0}: {1}", captureCtr, capture.Value);
captureCtr++;
}
}
}
}
}
// The example displays the following output:
// The match: This is the first sentence.
// Group 0: This is the first sentence.
// Capture 0: This is the first sentence.
// The match: Is it the beginning of a literary masterpiece?
// Group 0: Is it the beginning of a literary masterpiece?
// Capture 0: Is it the beginning of a literary masterpiece?
// The match: I think not.
// Group 0: I think not.
// Capture 0: I think not.
// The match: Instead, it is a nonsensical paragraph.
// Group 0: Instead, it is a nonsensical paragraph.
// Capture 0: Instead, it is a nonsensical paragraph.
Por último, puede usar el elemento de grupo alineado (?n:) para suprimir las capturas automáticas grupo por grupo. En el siguiente ejemplo se modifica el modelo anterior para suprimir capturas sin nombre en el grupo exterior, ((?>\w+),?\s?). Observe que esto también suprime las capturas sin nombre en el grupo interno.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "This is the first sentence. Is it the beginning " + _
"of a literary masterpiece? I think not. Instead, " + _
"it is a nonsensical paragraph."
Dim pattern As String = "\b\(?(?n:(?>\w+),?\s?)+[\.!?]\)?"
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("The match: {0}", match.Value)
Dim groupCtr As Integer = 0
For Each group As Group In match.Groups
Console.WriteLine(" Group {0}: {1}", groupCtr, group.Value)
groupCtr += 1
Dim captureCtr As Integer = 0
For Each capture As Capture In group.Captures
Console.WriteLine(" Capture {0}: {1}", captureCtr, capture.Value)
captureCtr += 1
Next
Next
Next
End Sub
End Module
' The example displays the following output:
' The match: This is the first sentence.
' Group 0: This is the first sentence.
' Capture 0: This is the first sentence.
' The match: Is it the beginning of a literary masterpiece?
' Group 0: Is it the beginning of a literary masterpiece?
' Capture 0: Is it the beginning of a literary masterpiece?
' The match: I think not.
' Group 0: I think not.
' Capture 0: I think not.
' The match: Instead, it is a nonsensical paragraph.
' Group 0: Instead, it is a nonsensical paragraph.
' Capture 0: Instead, it is a nonsensical paragraph.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "This is the first sentence. Is it the beginning " +
"of a literary masterpiece? I think not. Instead, " +
"it is a nonsensical paragraph.";
string pattern = @"\b\(?(?n:(?>\w+),?\s?)+[\.!?]\)?";
foreach (Match match in Regex.Matches(input, pattern))
{
Console.WriteLine("The match: {0}", match.Value);
int groupCtr = 0;
foreach (Group group in match.Groups)
{
Console.WriteLine(" Group {0}: {1}", groupCtr, group.Value);
groupCtr++;
int captureCtr = 0;
foreach (Capture capture in group.Captures)
{
Console.WriteLine(" Capture {0}: {1}", captureCtr, capture.Value);
captureCtr++;
}
}
}
}
}
// The example displays the following output:
// The match: This is the first sentence.
// Group 0: This is the first sentence.
// Capture 0: This is the first sentence.
// The match: Is it the beginning of a literary masterpiece?
// Group 0: Is it the beginning of a literary masterpiece?
// Capture 0: Is it the beginning of a literary masterpiece?
// The match: I think not.
// Group 0: I think not.
// Capture 0: I think not.
// The match: Instead, it is a nonsensical paragraph.
// Group 0: Instead, it is a nonsensical paragraph.
// Capture 0: Instead, it is a nonsensical paragraph.
Volver al principio
Expresiones regulares compiladas
De forma predeterminada, las expresiones regulares se interpretan en .NET Framework. Cuando se crea una instancia de un objeto Regex o se llama a un método Regex estático, el modelo de expresión regular se analiza en un conjunto de códigos de operación personalizados y un intérprete usa estos códigos de operación para ejecutar la expresión regular. Esto implica un equilibrio: el costo de inicializar el motor de expresiones regulares se minimiza a expensas del rendimiento en tiempo de ejecución.
Puede usar expresiones regulares compiladas en lugar de interpretadas mediante la opción RegexOptions.Compiled. En este caso, cuando un modelo se pasa al motor de expresiones regulares, se analiza en un conjunto de códigos de operación y, a continuación, se convierte en lenguaje intermedio de Microsoft (MSIL), que se puede pasar directamente al Common Language Runtime. Las expresiones regulares de compilación maximizan el rendimiento en tiempo de ejecución a expensas del tiempo de inicialización.
| Nota |
|---|
Una expresión regular solo puede estar compilada proporcionando el valor RegexOptions.Compiled al parámetro options de un constructor de clases Regex o un método de coincidencia de modelos estático.No está disponible como una opción alineada. |
Puede usar expresiones regulares compiladas en llamadas a expresiones regulares estáticas y de instancia. En expresiones regulares estáticas, la opción RegexOptions.Compiled se pasa al parámetro options del método de coincidencia de modelos de expresión regular. En expresiones regulares de instancia, se pasa al parámetro options del constructor de clase Regex. En ambos casos, da como resultado un rendimiento mejorado.
Sin embargo, esta mejora en el rendimiento solo se produce bajo las siguientes condiciones:
Un objeto Regex que representa una expresión regular estática se usa en varias llamadas a los métodos de coincidencia de modelos de expresión regular.
No se permite al objeto Regex salir del ámbito, de modo que se pueda reutilizar.
Una expresión regular estática se usa en varias llamadas a los métodos de coincidencia de modelos de expresión regular. (La mejora de rendimiento es posible porque las expresiones regulares usadas en llamadas del método estático las almacena en memoria caché. el motor de expresiones regulares.)
| Nota |
|---|
La opción RegexOptions.Compiled no está relacionada con el método Regex.CompileToAssembly, que crea un ensamblado del propósito especial que contiene expresiones regulares de compilación predefinidas. |
Volver al principio
Ignorar espacio en blanco
De forma predeterminada, el espacio en blanco en un modelo de expresión regular es significativo; obliga al motor de expresiones regulares a coincidir con un carácter de espacio en blanco en la cadena de entrada. Por eso, la expresión regular "\b\w+\s" y "\b\w+ " son expresiones regulares prácticamente equivalentes. Además, cuando la almohadilla (#) se encuentra en un modelo de expresión regular, se interpreta como un carácter literal con que se va a hacer coincidir.
La opción RegexOptions.IgnorePatternWhitespace, o la opción alineada x, cambia este comportamiento predeterminado como se muestra a continuación:
Se omite el espacio en blanco sin escape en el modelo de expresión regular. Para formar parte de un modelo de expresión regular, los caracteres de espacio en blanco deben ser caracteres de escape (como por ejemplo, \s o "\ ").
.gif "Nota importante")
ImportanteEl espacio en blanco dentro de una clase de caracteres se interpreta literalmente sin tener en cuenta el uso de la opción RegexOptions.IgnorePatternWhitespace.Por ejemplo, el modelo de expresión regular [ .,;:] coincide con cualquier carácter de espacio en blanco único, punto, coma, punto y coma o dos puntos.
La almohadilla (#) se interpreta como el principio de un comentario, en lugar de como un carácter literal. Todo el texto en el modelo de expresión regular del carácter # al final de la cadena se interpreta como un comentario.
Habilitar esta opción ayuda a simplificar expresiones regulares que son a menudo difíciles de analizar y entender. Mejora la legibilidad y hace posible documentar una expresión regular.
En el ejemplo siguiente se define el modelo de expresión regular siguiente:
\b \(? ( (?>\w+) ,? \s? )+ [\.!?] \)? # Matches an entire sentence.
Este modelo es similar al modelo definido en la sección Solo capturas explícitas la sección, salvo que usa la opción RegexOptions.IgnorePatternWhitespace para omitir el espacio en blanco del modelo.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "This is the first sentence. Is it the beginning " + _
"of a literary masterpiece? I think not. Instead, " + _
"it is a nonsensical paragraph."
Dim pattern As String = "\b \(? ( (?>\w+) ,?\s? )+ [\.!?] \)? # Matches an entire sentence."
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnorePatternWhitespace)
Console.WriteLine(match.Value)
Next
End Sub
End Module
' The example displays the following output:
' This is the first sentence.
' Is it the beginning of a literary masterpiece?
' I think not.
' Instead, it is a nonsensical paragraph.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "This is the first sentence. Is it the beginning " +
"of a literary masterpiece? I think not. Instead, " +
"it is a nonsensical paragraph.";
string pattern = @"\b\(?((?>\w+),?\s?)+[\.!?]\)?";
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnorePatternWhitespace))
Console.WriteLine(match.Value);
}
}
// The example displays the following output:
// This is the first sentence.
// Is it the beginning of a literary masterpiece?
// I think not.
// Instead, it is a nonsensical paragraph.
En el siguiente ejemplo se usa la opción (?x) insertada para omitir el espacio en blanco del modelo.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "This is the first sentence. Is it the beginning " + _
"of a literary masterpiece? I think not. Instead, " + _
"it is a nonsensical paragraph."
Dim pattern As String = "(?x)\b \(? ( (?>\w+) ,?\s? )+ [\.!?] \)? # Matches an entire sentence."
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:
' This is the first sentence.
' Is it the beginning of a literary masterpiece?
' I think not.
' Instead, it is a nonsensical paragraph.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "This is the first sentence. Is it the beginning " +
"of a literary masterpiece? I think not. Instead, " +
"it is a nonsensical paragraph.";
string pattern = @"(?x)\b \(? ( (?>\w+) ,?\s? )+ [\.!?] \)? # Matches an entire sentence.";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(match.Value);
}
}
// The example displays the following output:
// This is the first sentence.
// Is it the beginning of a literary masterpiece?
// I think not.
// Instead, it is a nonsensical paragraph.
Volver al principio
Modo de derecha a izquierda
De manera predeterminada, el motor de la expresión regular busca de izquierda a derecha. Puede invertir la dirección de búsqueda mediante la opción RegexOptions.RightToLeft. La búsqueda comienza automáticamente en la última posición de caracteres de la cadena. Para los métodos de coincidencia de modelos que incluyen un parámetro de posición inicial, como Regex.Match(String, Int32), la posición inicial es el índice de la posición del carácter situado más a la derecha en la que la búsqueda va a comenzar.
| Nota |
|---|
El modelo de derecha a izquierda solo está disponible cuando se proporciona el valor RegexOptions.RightToLeft al parámetro options de un constructor de clase Regex o un método de coincidencia de modelos estático.No está disponible como una opción alineada. |
La opción RegexOptions.RightToLeft sólo cambia la dirección de búsqueda; no interpreta el modelo de expresión regular de derecha a izquierda. Por ejemplo, la expresión regular \bb\w+\s coincide con palabras que comienzan por la letra "b" y van seguidas de un carácter de espacio en blanco. En el siguiente ejemplo, la cadena de entrada está compuesta por tres palabras que incluyen uno o más caracteres de "b." La primera palabra comienza con "b", la segunda finaliza con "b" y la tercera incluye dos caracteres "b" en medio de la palabra. Como el resultado del ejemplo muestra, solo la primera palabra coincide con el modelo de expresión regular.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\bb\w+\s"
Dim input As String = "builder rob rabble"
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.RightToLeft)
Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next
End Sub
End Module
' The example displays the following output:
' 'builder ' found at position 0.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\bb\w+\s";
string input = "builder rob rabble";
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.RightToLeft))
Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);
}
}
// The example displays the following output:
// 'builder ' found at position 0.
También observe que la aserción de búsqueda anticipada ((?=subexpresión) elemento del lenguaje) y la aserción de búsqueda anticipada ((?<=subexpresión) elemento del lenguaje) no cambian la dirección. Las aserciones de búsqueda anticipada buscan a la derecha; las aserciones de búsqueda tardía buscan a la izquierda. Por ejemplo, la expresión regular (?<=\d{1,2}\s)\w+,*\s\d{4} usa la aserción de búsqueda tardía para comprobar una fecha que precede a un nombre de mes. A continuación, la expresión regular coincide con el mes y el año. Para obtener información sobre las aserciones de búsqueda anticipada y de búsqueda tardía, vea Construcciones de agrupamiento.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim inputs() As String = { "1 May 1917", "June 16, 2003" }
Dim pattern As String = "(?<=\d{1,2}\s)\w+,?\s\d{4}"
For Each input As String In inputs
Dim match As Match = Regex.Match(input, pattern, RegexOptions.RightToLeft)
If match.Success Then
Console.WriteLine("The date occurs in {0}.", match.Value)
Else
Console.WriteLine("{0} does not match.", input)
End If
Next
End Sub
End Module
' The example displays the following output:
' The date occurs in May 1917.
' June 16, 2003 does not match.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string[] inputs = { "1 May 1917", "June 16, 2003" };
string pattern = @"(?<=\d{1,2}\s)\w+,?\s\d{4}";
foreach (string input in inputs)
{
Match match = Regex.Match(input, pattern, RegexOptions.RightToLeft);
if (match.Success)
Console.WriteLine("The date occurs in {0}.", match.Value);
else
Console.WriteLine("{0} does not match.", input);
}
}
}
// The example displays the following output:
// The date occurs in May 1917.
// June 16, 2003 does not match.
El modelo de expresión regular se define como se muestra en la tabla siguiente.
Modelo |
Descripción |
|---|---|
(?<=\d{1,2}\s) |
El principio de la coincidencia debe ir precedido de uno o dos dígitos decimales seguidos por un espacio. |
\w+ |
Buscar una coincidencia con uno o más caracteres de palabra. |
,* |
Buscar una coincidencia con cero o un carácter de coma. |
\s |
Hacer coincidir con un carácter que sea un espacio en blanco. |
\d{4} |
Buscar coincidencias con cuatro dígitos decimales. |
Volver al principio
Comportamiento del motor de búsqueda de coincidencias ECMAScript
De manera predeterminada, el que el motor de expresiones regulares usa el comportamiento canónico a la hora de buscar una coincidencia del modelo de expresión regular con el texto de entrada. Sin embargo, puede indicar al motor de expresiones regulares que use el comportamiento del motor de búsqueda de coincidencias ECMAScript especificando la opción RegexOptions.ECMAScript.
| Nota |
|---|
El comportamiento conforme a ECMAScript sólo está disponible cuando se proporciona el valor RegexOptions.ECMAScript al parámetro options de un constructor de clase Regex o un método de coincidencia de modelos estático.No está disponible como una opción alineada. |
La opción RegexOptions.ECMAScript también se pueden combinar con las opciones RegexOptions.IgnoreCase y RegexOptions.Multiline. El uso de cualquier otra opción en una expresión regular produce ArgumentOutOfRangeException.
El comportamiento de ECMAScript y las expresiones regulares canónicas difieren en tres áreas: sintaxis de clase de caracteres, grupos de captura con una referencia así mismos e interpretación de octales y de referencias inversas.
Sintaxis de clase de caracteres. Ya que las expresiones regulares canónicas admiten Unicode mientras que ECMAScript no, las clases de caracteres en ECMAScript tienen una sintaxis más limitada y algunos elementos del lenguaje de la clase de caracteres tienen un significado diferente. Por ejemplo, ECMAScript no admite elementos del lenguaje como la categoría Unicode o elementos de bloque \p y \P. Del mismo modo, el elemento \w, que coincide con un carácter de una palabra, es equivalente a la clase de caracteres [a-zA-Z_0-9] al utilizar ECMAScript y [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}] cuando se usa el comportamiento canónico. Para obtener más información, vea Clases de carácter.
En el siguiente ejemplo se muestra la diferencia entre la coincidencia de modelos canónico y ECMAScript. Define una expresión regular, \b(\w+\s*)+, que coincide con palabras que seguidas por caracteres de espacio en blanco. La entrada consta de dos cadenas, una que usa el juego de caracteres latinos y otra que usa el juego de caracteres cirílicos. Como se muestra en el resultado, la llamada al método Regex.IsMatch(String, String, RegexOptions) que usa el motor de búsqueda de coincidencias ECMAScript da un error al coincidir con las palabras cirílicas, mientras que la llamada al método que usa la concordancia canónica coincide con estas palabras.
Imports System.Text.RegularExpressions Module Example Public Sub Main() Dim values() As String = { "целый мир", "the whole world" } Dim pattern As String = "\b(\w+\s*)+" For Each value In values Console.Write("Canonical matching: ") If Regex.IsMatch(value, pattern) Console.WriteLine("'{0}' matches the pattern.", value) Else Console.WriteLine("{0} does not match the pattern.", value) End If Console.Write("ECMAScript matching: ") If Regex.IsMatch(value, pattern, RegexOptions.ECMAScript) Console.WriteLine("'{0}' matches the pattern.", value) Else Console.WriteLine("{0} does not match the pattern.", value) End If Console.WriteLine() Next End Sub End Module ' The example displays the following output: ' Canonical matching: 'целый мир' matches the pattern. ' ECMAScript matching: целый мир does not match the pattern. ' ' Canonical matching: 'the whole world' matches the pattern. ' ECMAScript matching: 'the whole world' matches the pattern.using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string[] values = { "целый мир", "the whole world" }; string pattern = @"\b(\w+\s*)+"; foreach (var value in values) { Console.Write("Canonical matching: "); if (Regex.IsMatch(value, pattern)) Console.WriteLine("'{0}' matches the pattern.", value); else Console.WriteLine("{0} does not match the pattern.", value); Console.Write("ECMAScript matching: "); if (Regex.IsMatch(value, pattern, RegexOptions.ECMAScript)) Console.WriteLine("'{0}' matches the pattern.", value); else Console.WriteLine("{0} does not match the pattern.", value); Console.WriteLine(); } } } // The example displays the following output: // Canonical matching: 'целый мир' matches the pattern. // ECMAScript matching: целый мир does not match the pattern. // // Canonical matching: 'the whole world' matches the pattern. // ECMAScript matching: 'the whole world' matches the pattern.Grupos de captura con una referencia así mismos. Una clase de captura de expresiones regulares con una referencia inversa se debe actualizar en cada iteración de captura. Como se muestra en el siguiente ejemplo, esta característica permite que la expresión regular ((a+)(\1) ?)+ coincida con la cadena de entrada " aa aaaa aaaaaa " al usar ECMAScript, pero no al usar la concordancia canónica.
La expresión regular se define como se muestra en la tabla siguiente.
Modelo
Descripción
(a+)
Coincide con la letra "a" una o más veces. Éste es el segundo grupo de captura.
(\1)
Hacer coincidir con la subcadena capturada por el primer grupo de capturas. Éste es el tercer grupo de captura.
?
Buscar una coincidencia de cero o un espacio.
((a+)(\1) ?)+
Busca una o varias coincidencias con el modelo de uno varios caracteres "a" seguidos por una cadena que coincide con el primer grupo de captura seguidos de cero o un carácter de espacio en blanco. Éste es el primer grupo de captura.
Resolución de ambigüedades entre secuencias de escape octal y referencias inversas. En la tabla siguiente se resumen las diferencias en la interpretación de octales y de referencias inversas con expresiones canónicas y con expresiones regulares ECMAScript.
Expresión regular
Comportamiento canónico
Comportamiento ECMAScript
\0 seguido de 0 a 2 dígitos octales
Se interpreta como un octal. Por ejemplo, \044 se interpreta siempre como un valor octal y significa "$".
El mismo comportamiento
\ va seguida de un dígito del 1 al 9, sin dígitos decimales adicionales,
Se interpreta como una referencia inversa. Por ejemplo, \9 siempre significa una referencia inversa de 9, incluso si no existe un noveno grupo de captura. Si el grupo de captura no existe, el analizador de expresiones regulares produce una excepción ArgumentException.
Si existe un único grupo de captura de dígitos decimales, se interpreta como una referencia inversa de ese dígito. En caso contrario, interprete el valor como un literal.
\ va seguida de un dígito del 1 al 9 y, a continuación, de dígitos de decimales adicionales, se interpreta como un valor decimal.
Interpreta los dígitos como un valor decimal. Si existe dicho grupo de captura, la expresión se interpreta como una referencia inversa.
De lo contrario, se interpretan los dígitos octales iniciales hasta el octal 377; es decir, solo se tienen en cuenta los 8 bits de orden inferior del valor. El resto de los dígitos se interpretan como literales. Por ejemplo, en la expresión \3000, si existe el grupo de captura de 300, se interpreta como una referencia inversa de 300; si no existe el grupo de captura de 300, se interpreta como el octal 300 seguido de 0.
Se interpreta como una referencia inversa convirtiendo los dígitos que sea posible a un valor decimal que haga referencia a una captura. Si no se puede convertir ningún dígito, se interpreta como un octal usando los dígitos octales iniciales hasta el octal 377; los dígitos restantes se interpretan como literales.
Volver al principio
Comparación usando la referencia cultural de todos los idiomas
De forma predeterminada, cuando el motor de expresiones regulares realiza las comparaciones sin distinción entre mayúsculas y minúsculas, usa las convenciones de uso de mayúsculas de la referencia cultural actual para determinar caracteres equivalentes de mayúsculas y minúsculas.
Sin embargo, este comportamiento no es conveniente para algunos tipos de comparaciones, especialmente al comparar los datos proporcionados por el usuario con los nombres de recursos del sistema, como contraseñas, archivos o direcciones URL. En el ejemplo siguiente se muestra este escenario. El código está pensado para bloquear el acceso a cualquier recurso cuya dirección URL vaya precedida por FILE://. La expresión regular intenta una coincidencia sin distinción entre mayúsculas y minúsculas con la cadena mediante la expresión regular $FILE://. Sin embargo, cuando la referencia cultural del sistema actual es tr-TR (Turco-Turquía), "I" no es la mayúscula equivalente a "i". Como resultado, la llamada al método Regex.IsMatch devuelve false y se permite el acceso al archivo.
Dim defaultCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
Thread.CurrentThread.CurrentCulture = New CultureInfo("tr-TR")
Dim input As String = "file://c:/Documents.MyReport.doc"
Dim pattern As String = "$FILE://"
Console.WriteLine("Culture-sensitive matching ({0} culture)...", _
Thread.CurrentThread.CurrentCulture.Name)
If Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase) Then
Console.WriteLine("URLs that access files are not allowed.")
Else
Console.WriteLine("Access to {0} is allowed.", input)
End If
Thread.CurrentThread.CurrentCulture = defaultCulture
' The example displays the following output:
' Culture-sensitive matching (tr-TR culture)...
' Access to file://c:/Documents.MyReport.doc is allowed.
CultureInfo defaultCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new CultureInfo("tr-TR");
string input = "file://c:/Documents.MyReport.doc";
string pattern = "FILE://";
Console.WriteLine("Culture-sensitive matching ({0} culture)...",
Thread.CurrentThread.CurrentCulture.Name);
if (Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase))
Console.WriteLine("URLs that access files are not allowed.");
else
Console.WriteLine("Access to {0} is allowed.", input);
Thread.CurrentThread.CurrentCulture = defaultCulture;
// The example displays the following output:
// Culture-sensitive matching (tr-TR culture)...
// Access to file://c:/Documents.MyReport.doc is allowed.
| Nota |
|---|
Para obtener más información sobre las comparaciones de cadenas que distinguen entre mayúsculas y minúsculas y que usan la referencia cultural de todos los idiomas, vea Procedimientos recomendados para el uso de cadenas en .NET Framework. |
En lugar de usar las comparaciones sin distinción entre mayúsculas y minúsculas de la referencia cultural actual, puede especificar la opción RegexOptions.CultureInvariant para omitir las diferencias culturales de idioma y usar las convenciones de la referencia cultural de todos los idiomas.
| Nota |
|---|
La comparación usando la referencia cultural de todos los idiomas solo está disponible proporcionando el valor RegexOptions.CultureInvariant al parámetro options de un constructor de clases Regex o un método de coincidencia de modelos estático.No está disponible como una opción alineada. |
El siguiente ejemplo es idéntico al ejemplo anterior, salvo en que el método estático Regex.IsMatch(String, String, RegexOptions) se llama con opciones que incluyenRegexOptions.CultureInvariant. Incluso si la referencia cultural actual está establecida en turco (Turquía), el motor de expresiones regulares puede coincidir correctamente con "FILE" y "file" y bloquear el acceso al recurso de archivo.
Dim defaultCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
Thread.CurrentThread.CurrentCulture = New CultureInfo("tr-TR")
Dim input As String = "file://c:/Documents.MyReport.doc"
Dim pattern As String = "$FILE://"
Console.WriteLine("Culture-insensitive matching...")
If Regex.IsMatch(input, pattern, _
RegexOptions.IgnoreCase Or RegexOptions.CultureInvariant) Then
Console.WriteLine("URLs that access files are not allowed.")
Else
Console.WriteLine("Access to {0} is allowed.", input)
End If
Thread.CurrentThread.CurrentCulture = defaultCulture
' The example displays the following output:
' Culture-insensitive matching...
' URLs that access files are not allowed.
CultureInfo defaultCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new CultureInfo("tr-TR");
string input = "file://c:/Documents.MyReport.doc";
string pattern = "FILE://";
Console.WriteLine("Culture-insensitive matching...");
if (Regex.IsMatch(input, pattern,
RegexOptions.IgnoreCase | RegexOptions.CultureInvariant))
Console.WriteLine("URLs that access files are not allowed.");
else
Console.WriteLine("Access to {0} is allowed.", input);
Thread.CurrentThread.CurrentCulture = defaultCulture;
// The example displays the following output:
// Culture-insensitive matching...
// URLs that access files are not allowed.
Volver al principio