Regex.Escape(String) Methode

Definition

Versieht einen minimalen Satz an Zeichen (\, *, +, ?, |, {, [, (,), ^, $,., # und Leerzeichen) mit Escapezeichen, indem diese durch die jeweils entsprechende Escapesequenz ersetzt werden.Escapes a minimal set of characters (\, *, +, ?, |, {, [, (,), ^, $, ., #, and white space) by replacing them with their escape codes. Damit wird die Engine für reguläre Ausdrücke angewiesen, diese Zeichen als Literale statt als Metazeichen zu interpretieren.This instructs the regular expression engine to interpret these characters literally rather than as metacharacters.

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

Parameter

str
String

Die Eingabezeichenfolge mit dem zu konvertierenden Text.The input string that contains the text to convert.

Gibt zurück

Eine Zeichenfolge, in der Metazeichen in die entsprechenden Escapecodes konvertiert wurden.A string of characters with metacharacters converted to their escaped form.

Ausnahmen

str ist null.str is null.

Beispiele

Im folgenden Beispiel werden Kommentare aus Text extrahiert.The following example extracts comments from text. Dabei wird davon ausgegangen, dass die Kommentare durch ein Begin Comment-Symbol und ein Symbol für das Ende des Kommentars getrennt sind, das vom Benutzer ausgewählt wird.It assumes that the comments are delimited by a begin comment symbol and an end comment symbol that is selected by the user. Da die Kommentar Symbole buchstäblich interpretiert werden sollen, werden Sie an die Escape -Methode übergeben, um sicherzustellen, dass Sie nicht als Metazeichen interpretiert werden können.Because the comment symbols are to be interpreted literally, they are passed to the Escape method to ensure that they cannot be misinterpreted as metacharacters. Außerdem wird im Beispiel explizit überprüft, ob das vom Benutzer eingegebene Symbol für das Ende des Kommentars eine schließende eckige Klammer (]) oder geschweifte Klammer (}) ist.In addition, the example explicitly checks whether the end comment symbol entered by the user is a closing bracket (]) or brace (}). Wenn dies der Fall ist, wird der Klammer\oder der geschweiften Klammer ein umgekehrter Schrägstrich () vorangestellt, sodass Sie buchstäblich interpretiert wird.If it is, a backslash character (\) is prepended to the bracket or brace so that it is interpreted literally. Beachten Sie, dass im Beispiel auch Match.Groups die-Auflistung verwendet wird, um nur den Kommentar anzuzeigen, anstatt den Kommentar mit seinen öffnenden und schließenden Kommentar Symbolen anzuzeigen.Note that the example also uses the Match.Groups collection to display the comment only, rather than the comment together with its opening and closing comment symbols.

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

Hinweise

EscapeKonvertiert eine Zeichenfolge so, dass die Engine für reguläre Ausdrücke alle Metazeichen interpretiert, die Sie möglicherweise als Zeichen Literale enthalten.Escape converts a string so that the regular expression engine will interpret any metacharacters that it may contain as character literals. Stellen Sie sich beispielsweise einen regulären Ausdruck vor, der zum Extrahieren von Kommentaren konzipiert ist, die durch gerade öffnende und schließende eckige Klammern ([und]) von Text getrennt sind.For example, consider a regular expression that is designed to extract comments that are delimited by straight opening and closing brackets ([ and ]) from text. Im folgenden Beispiel wird der reguläre Ausdruck "[(. *?)]" als Zeichenklasse interpretiert.In the following example, the regular expression "[(.*?)]" is interpreted as a character class. Anstelle von im Eingabetext eingebetteten Kommentaren vergleicht der reguläre Ausdruck jede öffnende oder schließende Klammer, jeden Zeitraum, dieses Sternchen oder dieses Fragezeichen.Rather than matching comments embedded in the input text, the regular expression matches each opening or closing parenthesis, period, asterisk, or question mark.

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: .

Wenn die öffnende eckige Klammer jedoch durch die Übergabe an die Escape -Methode geschützt wird, wird der reguläre Ausdruck beim Abgleichen von Kommentaren, die in die Eingabe Zeichenfolge eingebettet sind, erfolgreich ausgeführt.However, if the opening bracket is escaped by passing it to the Escape method, the regular expression succeeds in matching comments that are embedded in the input string. Dies wird anhand des folgenden Beispiels veranschaulicht.The following example illustrates this.

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?]

In einem regulären Ausdruck, der mithilfe von statischem Text definiert wird, können Zeichen, die buchstäblich anstelle von Metazeichen interpretiert werden sollen, mit einem umgekehrten Schrägstrich (\) und durch Aufrufen der Escape -Methode versehen werden.In a regular expression that is defined by using static text, characters that are to be interpreted literally rather than as metacharacters can be escaped by preceding them with a backslash symbol (\) as well as by calling the Escape method. In einem regulären Ausdruck, der dynamisch mithilfe von Zeichen definiert wird, die zur Entwurfszeit nicht bekannt sind Escape , ist das Aufrufen der-Methode besonders wichtig, um sicherzustellen, dass die Engine für reguläre Ausdrücke einzelne Zeichen als Literale interpretiert. als Metazeichen.In a regular expression that is defined dynamically using characters that are not known at design time, calling the Escape method is particularly important to ensure that the regular expression engine interprets individual characters as literals rather than as metacharacters.

Hinweis

Wenn ein Muster eines regulären Ausdrucks entweder das Nummern Zeichen (#) oder Literale Leerzeichen enthält, müssen Sie mit Escapezeichen versehen werden, wenn der RegexOptions.IgnorePatternWhitespace Eingabetext mit aktivierter Option analysiert wird.If a regular expression pattern includes either the number sign (#) or literal white-space characters, they must be escaped if input text is parsed with the RegexOptions.IgnorePatternWhitespace option enabled.

Während der Escape -Methode versieht gerade Klammer ([) öffnen und geschweifte Klammer ({)-Zeichen, es ist nicht mit Escapezeichen versehen die entsprechenden Zeichen schließen (] und}).While the Escape method escapes the straight opening bracket ([) and opening brace ({) characters, it does not escape their corresponding closing characters (] and }). In den meisten Fällen ist das Escapezeichen nicht erforderlich.In most cases, escaping these is not necessary. Wenn eine schließende eckige Klammer oder geschweifte Klammer nicht mit dem entsprechenden öffnenden Zeichen vorangestellt ist, interpretiert die Engine für reguläre Ausdrücke Sie als literalweise.If a closing bracket or brace is not preceded by its corresponding opening character, the regular expression engine interprets it literally. Wenn eine öffnende eckige Klammer oder geschweifte Klammer als Metazeichen interpretiert wird, interpretiert die Engine für reguläre Ausdrücke das erste entsprechende schließende Zeichen als Metazeichen.If an opening bracket or brace is interpreted as a metacharacter, the regular expression engine interprets the first corresponding closing character as a metacharacter. Wenn dies nicht das gewünschte Verhalten ist, muss die schließende Klammer oder geschweifte Klammer mit Escapezeichen versehen werden, indem\der umgekehrte Schrägstrich () explizit vorangestellt wird.If this is not the desired behavior, the closing bracket or brace should be escaped by explicitly prepending the backslash (\) character. Eine Abbildung finden Sie im Beispiel Abschnitt.For an illustration, see the Example section.

Gilt für:

Siehe auch