Regex.Escape(String) Méthode
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Exécute une séquence d’échappement d’un ensemble minimal de caractères (\, *, +, ?, |, {, [, (,), ^, $, ., #, et espaces blancs) en les remplaçant par leurs codes d’échappement. Cela indique au moteur d'expressions régulières qu'il doit interpréter ces caractères littéralement, et non comme des métacaractères.
public:
static System::String ^ Escape(System::String ^ str);public static string Escape (string str);static member Escape : string -> stringPublic Shared Function Escape (str As String) As StringParamètres
- str
- String
Chaîne d'entrée qui contient le texte à convertir.
Retours
Chaîne de caractères dont les métacaractères sont remplacés par leurs codes d'échappement.
Exceptions
str a la valeur null.
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.
Notes
Si un modèle d’expression régulière inclut le signe numérique (#) ou des espaces blancs littéraux, ils doivent être placés dans une séquence d’échappement si le texte d’entrée est analysé avec l’option RegexOptions.IgnorePatternWhitespace activée.
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.
