Regex.Escape(String) Méthode

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

Paramètres

Retours

Chaîne de caractères dont les métacaractères sont remplacés par leurs codes d'échappement.

Exceptions

Exemples

L’exemple suivant extrait les commentaires du texte. Il suppose que les commentaires sont délimités par un symbole de commentaire de début et un symbole de commentaire de fin sélectionné par l’utilisateur. Étant donné que les symboles de commentaire doivent être interprétés littéralement, ils sont transmis à la Escape méthode pour s’assurer qu’ils ne peuvent pas être mal interprétés comme des métacharacteurs. En outre, l’exemple vérifie explicitement si le symbole de commentaire de fin entré par l’utilisateur est un crochet fermant (]) ou une accolade (}). Si tel est le cas, une barre oblique inverse (\) est ajoutée au crochet ou à l’accolade afin qu’elle soit interprétée littéralement. Notez que l’exemple utilise également la Match.Groups collection pour afficher le commentaire uniquement, plutôt que le commentaire avec ses symboles de commentaire d’ouverture et de fermeture.

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

Remarques

Escape convertit une chaîne afin que le moteur d’expression régulière interprète tous les métacharacteurs qu’il peut contenir en tant que littéraux de caractères. Par exemple, considérez une expression régulière conçue pour extraire des commentaires délimités par des crochets ouvrants et fermants ([ et ]) du texte. Dans l’exemple suivant, l’expression régulière « [(.*?)] » est interprétée comme une classe de caractères. Au lieu de mettre en correspondance les commentaires incorporés dans le texte d’entrée, l’expression régulière correspond à chaque parenthèse ouvrante ou fermante, point, astérisque ou point d’interrogation.

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

Toutefois, si le crochet ouvrant est placé dans une séquence d’échappement en le passant à la Escape méthode, l’expression régulière réussit à mettre en correspondance les commentaires incorporés dans la chaîne d’entrée. L'exemple suivant illustre ce comportement.

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

Dans une expression régulière définie à l’aide d’un texte statique, les caractères qui doivent être interprétés littéralement plutôt que comme métacharactaires peuvent être placés dans une séquence d’échappement en les précédant d’un symbole de barre oblique inverse (\) et en appelant la Escape méthode . Dans une expression régulière définie dynamiquement à l’aide de caractères qui ne sont pas connus au moment du design, l’appel de la Escape méthode est particulièrement important pour s’assurer que le moteur d’expression régulière interprète les caractères individuels comme des littéraux plutôt que comme des métacharactaires.

Alors que le Escape méthode s’échappe du crochet gauche ([) et l’accolade ouvrante ({}), il n’échappe pas leurs caractères de fermeture correspondants (] et}). Dans la plupart des cas, il n’est pas nécessaire de les échapper. Si un crochet fermant ou une accolade n’est pas précédé de son caractère d’ouverture correspondant, le moteur d’expression régulière l’interprète littéralement. Si un crochet ouvrant ou une accolade est interprété comme un métacharacteur, le moteur d’expression régulière interprète le premier caractère fermant correspondant comme un métacharacteur. Si ce n’est pas le comportement souhaité, le crochet fermant ou l’accolade doit être placé dans une séquence d’échappement en préparant explicitement la barre oblique inverse (\). Pour obtenir une illustration, consultez la section Exemple.

S’applique à

Voir aussi

• Unescape(String)
• Langage des expressions régulières - Aide-mémoire
• Caractères d'échappement dans les expressions régulières