Regex.Escape(String) Método

Definición

Espacio de nombres:

System.Text.RegularExpressions

Ensamblado:

System.Text.RegularExpressions.dll

Source:

Regex.cs

Aplica escape a un conjunto mínimo de caracteres (\, *, +, ?, |, {, [, (,), ^, $, ., #, y espacios en blanco) reemplazandolos por sus códigos de escape. Esto indica al motor de expresiones regulares que interprete los caracteres literalmente en lugar de como metacaracteres.

public:
 static System::String ^ Escape(System::String ^ str);

public static string Escape (string str);

static member Escape : string -> string

Public Shared Function Escape (str As String) As String

Parámetros

str

String

Cadena de entrada que contiene el texto que se va a convertir.

Devoluciones

String

Cadena de caracteres con metacaracteres convertidos a su forma de escape.

Excepciones

ArgumentNullException

str es null.

Ejemplos

En el ejemplo siguiente se extraen comentarios del texto. Se supone que los comentarios están delimitados por un símbolo de comentario inicial y un símbolo de comentario final seleccionado por el usuario. Dado que los símbolos de comentario se van a interpretar literalmente, se pasan al Escape método para asegurarse de que no se pueden interpretar incorrectamente como metacaractores. Además, el ejemplo comprueba explícitamente si el símbolo de comentario final especificado por el usuario es un corchete de cierre (]) o llave (}). Si es así, se antepone un carácter de barra diagonal inversa (\) al corchete o llave para que se interprete literalmente. Tenga en cuenta que en el ejemplo también se usa la Match.Groups colección para mostrar solo el comentario, en lugar del comentario junto con sus símbolos de comentario de apertura y cierre.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      ConsoleKeyInfo keyEntered;
      char beginComment, endComment;
      Console.Write("Enter begin comment symbol: ");
      keyEntered = Console.ReadKey();
      beginComment = keyEntered.KeyChar;
      Console.WriteLine();
      
      Console.Write("Enter end comment symbol: ");
      keyEntered = Console.ReadKey();
      endComment = keyEntered.KeyChar;
      Console.WriteLine();
      
      string input = "Text [comment comment comment] more text [comment]";
      string pattern;
      pattern = Regex.Escape(beginComment.ToString()) + @"(.*?)";
      string endPattern = Regex.Escape(endComment.ToString());
      if (endComment == ']' || endComment == '}') endPattern = @"\" + endPattern;
      pattern += endPattern;
      MatchCollection matches = Regex.Matches(input, pattern);
      Console.WriteLine(pattern);
      int commentNumber = 0;
      foreach (Match match in matches)
         Console.WriteLine("{0}: {1}", ++commentNumber, match.Groups[1].Value);
   }
}
// The example shows possible output from the example:
//       Enter begin comment symbol: [
//       Enter end comment symbol: ]
//       \[(.*?)\]
//       1: comment comment comment
//       2: comment

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim keyEntered As ConsoleKeyInfo
      Dim beginComment, endComment As Char
      Console.Write("Enter begin comment symbol: ")
      keyEntered = Console.ReadKey()
      beginComment = keyEntered.KeyChar
      Console.WriteLine()
      
      Console.Write("Enter end comment symbol: ")
      keyEntered = Console.ReadKey()
      endComment = keyEntered.KeyChar
      Console.WriteLine()
      
      Dim input As String = "Text [comment comment comment] more text [comment]"
      Dim pattern As String = Regex.Escape(beginComment.ToString()) + "(.*?)"
      Dim endPattern As String = Regex.Escape(endComment.ToString())
      If endComment = "]"c OrElse endComment = "}"c Then endPattern = "\" + endPattern
      pattern += endPattern
      
      Dim matches As MatchCollection = Regex.Matches(input, pattern)
      Console.WriteLine(pattern)
      Dim commentNumber As Integer = 0
      For Each match As Match In matches
         commentNumber += 1
         Console.WriteLine("{0}: {1}", commentNumber, match.Groups(1).Value)
      Next         
   End Sub
End Module
' The example shows possible output from the example:
'       Enter begin comment symbol: [
'       Enter end comment symbol: ]
'       \[(.*?)\]
'       1: comment comment comment
'       2: comment

Comentarios

Escape convierte una cadena para que el motor de expresiones regulares interprete los metadatos que pueda contener como literales de carácter. Por ejemplo, considere una expresión regular diseñada para extraer comentarios delimitados por corchetes de apertura y cierre rectos ([ y ]) del texto. En el ejemplo siguiente, la expresión regular "[(.*?)]" se interpreta como una clase de caracteres. En lugar de hacer coincidir los comentarios incrustados en el texto de entrada, la expresión regular coincide con cada paréntesis de apertura o cierre, punto, asterisco o signo de interrogación.

string pattern = "[(.*?)]"; 
string input = "The animal [what kind?] was visible [by whom?] from the window.";

MatchCollection matches = Regex.Matches(input, pattern);
int commentNumber = 0;
Console.WriteLine("{0} produces the following matches:", pattern);
foreach (Match match in matches)
   Console.WriteLine("   {0}: {1}", ++commentNumber, match.Value);  

// This example displays the following output:
//       [(.*?)] produces the following matches:
//          1: ?
//          2: ?
//          3: .

Dim pattern As String = "[(.*?)]" 
Dim input As String = "The animal [what kind?] was visible [by whom?] from the window."

Dim matches As MatchCollection = Regex.Matches(input, pattern)
Dim commentNumber As Integer = 0
Console.WriteLine("{0} produces the following matches:", pattern)
For Each match As Match In matches
   commentNumber += 1
   Console.WriteLine("{0}: {1}", commentNumber, match.Value)       
Next      
' This example displays the following output:
'       1: ?
'       2: ?
'       3: .

Sin embargo, si el corchete de apertura se escapa pasando al Escape método , la expresión regular se realiza correctamente en los comentarios coincidentes incrustados en la cadena de entrada. Esto se ilustra en el siguiente ejemplo:

string pattern = Regex.Escape("[") + "(.*?)]"; 
string input = "The animal [what kind?] was visible [by whom?] from the window.";

MatchCollection matches = Regex.Matches(input, pattern);
int commentNumber = 0;
Console.WriteLine("{0} produces the following matches:", pattern);
foreach (Match match in matches)
   Console.WriteLine("   {0}: {1}", ++commentNumber, match.Value);  

// This example displays the following output:
//       \[(.*?)] produces the following matches:
//          1: [what kind?]
//          2: [by whom?]

Dim pattern As String = Regex.Escape("[") + "(.*?)]" 
Dim input As String = "The animal [what kind?] was visible [by whom?] from the window."

Dim matches As MatchCollection = Regex.Matches(input, pattern)
Dim commentNumber As Integer = 0
Console.WriteLine("{0} produces the following matches:", pattern)
For Each match As Match In matches
   commentNumber += 1
   Console.WriteLine("   {0}: {1}", commentNumber, match.Value)  
Next
' This example displays the following output:
'       \[(.*?)] produces the following matches:
'          1: [what kind?]
'          2: [by whom?]

En una expresión regular que se define mediante texto estático, los caracteres que se van a interpretar literalmente en lugar de como metacaractores se pueden escapar precediéndolos con un símbolo de barra diagonal inversa (\), así como llamando al Escape método . En una expresión regular definida dinámicamente mediante caracteres que no se conocen en tiempo de diseño, llamar al Escape método es especialmente importante para asegurarse de que el motor de expresiones regulares interpreta caracteres individuales como literales en lugar de como metacaractores.

Nota

Si un patrón de expresión regular incluye el signo de número (#) o los caracteres de espacio en blanco literales, deben escaparse si el texto de entrada se analiza con la RegexOptions.IgnorePatternWhitespace opción habilitada.

Aunque el Escape método escapa del corchete de apertura recto ([) y los caracteres de llave de apertura ({), no se aplica un escape a sus caracteres de cierre correspondientes (] y }). En la mayoría de los casos, el escape no es necesario. Si un corchete o llave de cierre no está precedido por su carácter de apertura correspondiente, el motor de expresiones regulares lo interpreta literalmente. Si un corchete o llave de apertura se interpreta como metacaracter, el motor de expresiones regulares interpreta el primer carácter de cierre correspondiente como metacaracter. Si no es el comportamiento deseado, el corchete de cierre o llave debe escaparse anteponiendo explícitamente el carácter de barra diagonal inversa (\). Para obtener una ilustración, consulte la sección Ejemplo.

Consulte también

• Unescape(String)
• Lenguaje de expresiones regulares: referencia rápida
• Escapes de carácter en expresiones regulares