Caratteri di escape nelle espressioni regolariCharacter Escapes in Regular Expressions

La barra rovesciata (\) in un'espressione regolare indica una delle situazioni seguenti:The backslash (\) in a regular expression indicates one of the following:

  • Il carattere che segue è un carattere speciale, come illustrato nella tabella nella sezione seguente.The character that follows it is a special character, as shown in the table in the following section. Ad esempio, \b è un ancoraggio che indica che una corrispondenza di un'espressione regolare deve iniziare sul confine di una parola, \t rappresenta un carattere di tabulazione e \x020 rappresenta uno spazio.For example, \b is an anchor that indicates that a regular expression match should begin on a word boundary, \t represents a tab, and \x020 represents a space.

  • Un carattere che altrimenti verrebbe interpretato come un costrutto di linguaggio non di escape deve essere interpretato letteralmente.A character that otherwise would be interpreted as an unescaped language construct should be interpreted literally. Ad esempio, una parentesi graffa ({) segna l'inizio della definizione di un quantificatore, ma una barra rovesciata seguita da una parentesi graffa (\{) indica che il motore delle espressioni regolari deve trovare la corrispondenza con la parentesi graffa.For example, a brace ({) begins the definition of a quantifier, but a backslash followed by a brace (\{) indicates that the regular expression engine should match the brace. Analogamente, una singola barra rovesciata segna l'inizio di un costrutto di linguaggio di escape, ma due barre rovesciate (\\) indicano che il motore delle espressioni regolari deve trovare la corrispondenza con la barra rovesciata.Similarly, a single backslash marks the beginning of an escaped language construct, but two backslashes (\\) indicate that the regular expression engine should match the backslash.

Nota

Le sequenze di caratteri di escape vengono riconosciute nei modelli di espressioni regolari, ma non nei modelli di sostituzione.Character escapes are recognized in regular expression patterns but not in replacement patterns.

Caratteri di escape in .NETCharacter Escapes in .NET

La tabella seguente elenca i caratteri di escape supportati dalle espressioni regolari in .NET.The following table lists the character escapes supported by regular expressions in .NET.

Carattere o sequenzaCharacter or sequence DescrizioneDescription
Tutti i caratteri eccetto i seguenti:All characters except for the following:

.. $ ^ { [ ( | ) * + ?$ ^ { [ ( | ) * + ? |I caratteri diversi da quelli elencati nella colonna Carattere o sequenza non hanno un significato speciale nelle espressioni regolari, ma corrispondono a se stessi.|Characters other than those listed in the Character or sequence column have no special meaning in regular expressions; they match themselves.

I caratteri inclusi nella colonna Carattere o sequenza sono elementi speciali del linguaggio di espressioni regolari.The characters included in the Character or sequence column are special regular expression language elements. Per trovare una corrispondenza con essi in un'espressione regolare, è necessario aggiungere un carattere di escape o includerli in un gruppo di caratteri positivi.To match them in a regular expression, they must be escaped or included in a positive character group. Ad esempio, l'espressione regolare \$\d+ o [$]\d+ trova la corrispondenza con "$1200".For example, the regular expression \$\d+ or [$]\d+ matches "$1200".
\a Corrisponde a un carattere di controllo del segnale acustico di avviso, \u0007.Matches a bell (alarm) character, \u0007.
\b In una classe di caratteri [character_group] corrisponde a una carattere backspace, \u0008.In a [character_group] character class, matches a backspace, \u0008. Vedere Classi di caratteri. Al di fuori di una classe di caratteri, \b è un ancoraggio che corrisponde a un confine di parola.(See Character Classes.) Outside a character class, \b is an anchor that matches a word boundary. Vedere Ancoraggi.(See Anchors.)
\t Corrisponde a un carattere di tabulazione, \u0009.Matches a tab, \u0009.
\r Corrisponde a un carattere di ritorno a capo, \u000D.Matches a carriage return, \u000D. Si noti che \r non equivale al carattere di nuova riga, \n.Note that \r is not equivalent to the newline character, \n.
\v Corrisponde a un carattere di tabulazione verticale, \u000B.Matches a vertical tab, \u000B.
\f Corrisponde a un carattere di avanzamento carta, \u000C.Matches a form feed, \u000C.
\n Corrisponde a una nuova riga, \u000A.Matches a new line, \u000A.
\e Corrisponde a un carattere di escape, \u001B.Matches an escape, \u001B.
\ nnn\ nnn Corrisponde a un carattere ASCII dove nnn è costituito da due o tre cifre che rappresentano il codice carattere ottale.Matches an ASCII character, where nnn consists of two or three digits that represent the octal character code. Ad esempio, \040 rappresenta un carattere di spazio.For example, \040 represents a space character. Questo costrutto viene interpretato come un backreference se è costituito solo da una cifra, ad esempio \2 o se corrisponde al numero di un gruppo di acquisizione.This construct is interpreted as a backreference if it has only one digit (for example, \2) or if it corresponds to the number of a capturing group. Vedere Costrutti di backreference.(See Backreference Constructs.)
\x nn\x nn Corrisponde a un carattere ASCII dove nn è un codice carattere esadecimale a due cifre.Matches an ASCII character, where nn is a two-digit hexadecimal character code.
\c X\c X Corrisponde a un carattere di controllo ASCII, dove X è la lettera del carattere di controllo.Matches an ASCII control character, where X is the letter of the control character. Ad esempio, \cC corrisponde a CTRL-C.For example, \cC is CTRL-C.
\u nnnn\u nnnn Corrisponde a un'unità di codice UTF-16 il cui valore è l'esadecimale nnnn.Matches a UTF-16 code unit whose value is nnnn hexadecimal. Nota: la sequenza di caratteri di escape Perl 5 usata per specificare Unicode non è supportata da .NET.Note: The Perl 5 character escape that is used to specify Unicode is not supported by .NET. La sequenza di caratteri di escape Perl 5 ha il formato \x{####…}, dove #### è una serie di cifre esadecimali.The Perl 5 character escape has the form \x{####…}, where #### is a series of hexadecimal digits. Usare invece \unnnn.Instead, use \unnnn.
\ Quando è seguito da un carattere non riconosciuto come carattere di escape, corrisponde a tale carattere.When followed by a character that is not recognized as an escaped character, matches that character. Ad esempio, \* corrisponde a un asterisco () ed equivale a \x2A.For example, \* matches an asterisk () and is the same as \x2A.

EsempioAn Example

L'esempio seguente illustra l'uso di una sequenza di caratteri di escape in un'espressione regolare.The following example illustrates the use of character escapes in a regular expression. Viene analizzata una stringa contenente i nomi delle più grandi città del mondo e la relativa popolazione nel 2009.It parses a string that contains the names of the world's largest cities and their populations in 2009. Ogni nome di città è separato dalla relativa popolazione da un carattere di tabulazione (\t) o da una barra verticale (| o \u007c).Each city name is separated from its population by a tab (\t) or a vertical bar (| or \u007c). Le singole città e la relativa popolazione sono separate tra loro da un ritorno a capo e un avanzamento riga.Individual cities and their populations are separated from each other by a carriage return and line feed.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string delimited = @"\G(.+)[\t\u007c](.+)\r?\n";
      string input = "Mumbai, India|13,922,125\t\n" + 
                            "Shanghai, China\t13,831,900\n" + 
                            "Karachi, Pakistan|12,991,000\n" + 
                            "Delhi, India\t12,259,230\n" + 
                            "Istanbul, Turkey|11,372,613\n";
      Console.WriteLine("Population of the World's Largest Cities, 2009");
      Console.WriteLine();
      Console.WriteLine("{0,-20} {1,10}", "City", "Population");
      Console.WriteLine();
      foreach (Match match in Regex.Matches(input, delimited))
         Console.WriteLine("{0,-20} {1,10}", match.Groups[1].Value, 
                                            match.Groups[2].Value);
   }
}
// The example displyas the following output:
//       Population of the World's Largest Cities, 2009
//       
//       City                 Population
//       
//       Mumbai, India        13,922,125
//       Shanghai, China      13,831,900
//       Karachi, Pakistan    12,991,000
//       Delhi, India         12,259,230
//       Istanbul, Turkey     11,372,613
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim delimited As String = "\G(.+)[\t\u007c](.+)\r?\n"
      Dim input As String = "Mumbai, India|13,922,125" + vbCrLf + _
                            "Shanghai, China" + vbTab + "13,831,900" + vbCrLf + _
                            "Karachi, Pakistan|12,991,000" + vbCrLf + _
                            "Delhi, India" + vbTab + "12,259,230" + vbCrLf + _
                            "Istanbul, Turkey|11,372,613" + vbCrLf
      Console.WriteLine("Population of the World's Largest Cities, 2009")
      Console.WriteLine()
      Console.WriteLine("{0,-20} {1,10}", "City", "Population")
      Console.WriteLine()
      For Each match As Match In Regex.Matches(input, delimited)
         Console.WriteLine("{0,-20} {1,10}", match.Groups(1).Value, _
                                            match.Groups(2).Value)
      Next                         
   End Sub
End Module
' The example displays the following output:
'       Population of the World's Largest Cities, 2009
'       
'       City                 Population
'       
'       Mumbai, India        13,922,125
'       Shanghai, China      13,831,900
'       Karachi, Pakistan    12,991,000
'       Delhi, India         12,259,230
'       Istanbul, Turkey     11,372,613

L'espressione regolare \G(.+)[\t|\u007c](.+)\r?\n viene interpretata come illustrato nella tabella seguente.The regular expression \G(.+)[\t|\u007c](.+)\r?\n is interpreted as shown in the following table.

ModelloPattern DescrizioneDescription
\G Inizia la corrispondenza dove termina l'ultima corrispondenza.Begin the match where the last match ended.
(.+) Trova la corrispondenza con qualsiasi carattere uno o più volte.Match any character one or more times. Equivale al primo gruppo di acquisizione.This is the first capturing group.
[\t\u007c] Trova la corrispondenza con un carattere di tabulazione (\t) o una barra verticale (|).Match a tab (\t) or a vertical bar (|).
(.+) Trova la corrispondenza con qualsiasi carattere uno o più volte.Match any character one or more times. Equivale al secondo gruppo di acquisizione.This is the second capturing group.
\r?\n Trova la corrispondenza con zero o una occorrenza di un ritorno a capo seguito da una nuova riga.Match zero or one occurrence of a carriage return followed by a new line.

Vedere ancheSee Also

Linguaggio di espressioni regolari - Riferimento rapidoRegular Expression Language - Quick Reference