Regex.Escape(String) Metoda

Reference

Definice

Obor názvů:: System.Text.RegularExpressions

Sestavení:: System.Text.RegularExpressions.dll

Sestavení:: System.dll

Sestavení:: netstandard.dll

Source:: Regex.cs

Source:: Regex.cs

Source:: Regex.cs

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Vyloučí minimální sadu znaků (\, *, +, ?, |, {, [, (,), ^, $, ., #a prázdné znaky. Nahradí je řídicími kódy. To dává modulu regulárních výrazů pokyn, aby tyto znaky interpretovat doslovně, nikoli jako metacharaktery.

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

Parametry

str: String

Vstupní řetězec obsahující text, který se má převést.

Návraty

String

Řetězec znaků s metaznaátory převedenými na jejich řídicí tvar.

Výjimky

ArgumentNullException

str je null.

Příklady

Následující příklad extrahuje komentáře z textu. Předpokládá, že komentáře jsou oddělené počátečním symbolem komentáře a symbolem koncového komentáře, který uživatel vybral. Vzhledem k tomu, že symboly komentáře mají být interpretovány doslovně, jsou předány Escape metodě, aby se zajistilo, že je nelze chybně interpretovat jako metaznačky. Příklad navíc explicitně kontroluje, jestli je symbol koncového komentáře zadaný uživatelem pravou závorkou (]) nebo složenou závorkou (}). Pokud ano, znak zpětného lomítka (\) se předloží do závorky nebo závorky, aby se interpretoval doslovně. Všimněte si, že tento příklad také používá kolekci Match.Groups k zobrazení pouze komentáře, a nikoli komentáře společně se symboly pro otevření a uzavření komentáře.

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

Poznámky

Escape převede řetězec tak, že modul regulárních výrazů bude interpretovat všechny metaznaky, které může obsahovat jako literály znaků. Představte si například regulární výraz, který je navržený tak, aby z textu extrahovali komentáře oddělené rovnými levými a pravou závorkou ([ a ]). V následujícím příkladu je regulární výraz "[(.*?)] interpretován jako třída znaků. Místo odpovídajících komentářů vložených do vstupního textu se regulární výraz shoduje s každou levou nebo pravou závorkou, tečkou, hvězdičkou nebo otazníkem.

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

Pokud je však levá hranatá závorka předáním do Escape metody, regulární výraz úspěšně shodí komentáře, které jsou vloženy ve vstupním řetězci. Toto dokládá následující příklad.

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

V regulárním výrazu, který je definován pomocí statického textu, lze znaky, které mají být interpretovány doslovně, spíše než jako metacharaktery, uniknout tak, že před nimi bude znak zpětného lomítka (\) a také voláním Escape metody. V regulárním výrazu, který je definován dynamicky pomocí znaků, které nejsou známy v době návrhu Escape , je volání metody obzvláště důležité, aby se zajistilo, že modul regulárních výrazů interpretuje jednotlivé znaky jako literály, nikoli jako metaznačky.

Poznámka

Pokud vzor regulárního výrazu obsahuje znak čísla (#) nebo prázdné znaky literálu, musí být při analýze vstupního textu s povolenou RegexOptions.IgnorePatternWhitespace možností řídicí řídicí znak.

Escape I když metoda uvozuje znaky rovné levá hranatá závorka ([) a levá závorka ({), neunikne jejich odpovídajícím závěrečným znakům (] a }). Ve většině případů není jejich únik nutný. Pokud před pravou závorkou nebo složenou závorkou není odpovídající počáteční znak, modul regulárních výrazů ji interpretuje doslova. Pokud je levá závorka nebo složená závorka interpretována jako metacharakter, modul regulárních výrazů interpretuje první odpovídající uzavírací znak jako metaznač. Pokud se nejedná o požadované chování, uzavírací závorka nebo složená závorka by měla být uvozována explicitně před znakem zpětného lomítka (\). Obrázek najdete v části Příklad.

Platí pro