Caratteri di escape

Articolo
08/11/2011

La barra rovesciata (\) in un'espressione regolare indica una delle voci dell'elenco seguente:

Il carattere che la segue è un carattere speciale, come illustrato nella tabella nella sezione seguente. Ad esempio, \b è un ancoraggio che indica che una corrispondenza di un'espressione regolare deve iniziare in un confine di parola, \t rappresenta una scheda e \x020 rappresenta uno spazio.
Un carattere che in caso contrario sarebbe interpretato come un costrutto di linguaggio senza codice di escape deve essere interpretato letteralmente. Ad esempio, una parentesi graffa ({) inizia la definizione di un quantificatore, ma una barra rovesciata seguita da una parentesi graffa (\{) indica che il motore delle espressioni regolari deve trovare una corrispondenza con una parentesi graffa. Allo stesso modo, una sola barra rovesciata contrassegna l'inizio di un costrutto di linguaggio che utilizza caratteri di escape, ma due barre rovesciate (\\) indicano che il motore delle espressioni regolari deve trovare le corrispondenze con la barra rovesciata.

Nota
I caratteri di escape vengono riconosciuti nei modelli di espressione regolare, ma non nei criteri di sostituzione.

Caratteri di escape in .NET Framework

Nella tabella seguente sono elencati i caratteri di escape supportati dalle espressioni regolari in .NET Framework.

Carattere o sequenza	Oggetto di descrizione
Tutti i caratteri tranne i seguenti: . $ ^ { [ ( \| ) * + ? \	Questi caratteri non presentano alcun significato speciale nelle espressioni regolari; corrispondono a essi stessi.
\a	Trova la corrispondenza con un carattere di controllo (avviso) \u0007.
\b	In una classe di caratteri [gruppo_caratteri] trova la corrispondenza di un carattere backspace, \u0008. Per ulteriori informazioni, vedere Classi di caratteri. All'esterno di una classe di caratteri, \b è un ancoraggio che corrisponde a un confine di parola. Per ulteriori informazioni, vedere Ancoraggi in espressioni regolari.
\t	Trova la corrispondenza con un carattere di tabulazione, \u0009.
\r	Trova la corrispondenza con un ritorno a capo, \u000D. \r non equivale al carattere di nuova riga \n.
\v	Trova la corrispondenza con un carattere di tabulazione verticale, \u000B.
\f	Trova la corrispondenza con un carattere di avanzamento carta, \u000C.
\n	Trova la corrispondenza con una nuova riga, \u000A.
\e	Trova la corrispondenza con un carattere di escape, \u001B.
\nnn	Trova la corrispondenza con un carattere ASCII, dove nnn è costituito da fino a tre cifre che rappresentano il codice carattere ottale. Ad esempio, \040 rappresenta uno spazio. Tuttavia, questo costrutto viene interpretato come un backreference se dispone di una sola cifra (ad esempio, \2) o se corrisponde al numero di un gruppo di acquisizione. Per ulteriori informazioni, vedere Costrutti di backreference.
\xnn	Trova la corrispondenza con un carattere ASCII, dove nn è un codice carattere esadecimale a due cifre.
\cX	Trova la corrispondenza con un carattere di controllo ASCII, dove X è la lettera del carattere di controllo. Ad esempio, \cC è CTRL-C.
\unnnn	Trova la corrispondenza con un carattere Unicode, dove nnnn è un punto di codice esadecimale a quattro cifre. Nota La sequenza di caratteri di escape Perl 5 utilizzata per specificare Unicode non è supportata in .NET Framework.Il carattere di escape di Perl 5 ha il formato \x{nnnn…}, dove nnnn… è una serie di cifre esadecimali.Utilizzare invece \unnnn.
\	Quando è seguito da un carattere non riconosciuto come carattere di escape, corrisponde a quel carattere. Ad esempio, \* corrisponde a un asterisco ed equivale a \x2A.

Un esempio

Nell'esempio seguente viene illustrato l'utilizzo dei caratteri di escape in un'espressione regolare. Analizza una stringa che contiene i nomi delle più grandi città del mondo e le relative popolazioni nel 2009. Ogni nome di città è separato dalla relativa popolazione mediante un carattere di tabulazione (\t) o un carattere di barra verticale (| o \u007c). Le singole città e le relative popolazioni sono separate fra loro da un ritorno a capo e un avanzamento riga.

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 + _
                            "Dehli, 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
'       Dehli, India         12,259,230
'       Istanbul, Turkey     11,372,613

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" + 
                            "Dehli, 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
//       Dehli, India         12,259,230
//       Istanbul, Turkey     11,372,613

L'espressione regolare \G(.+)[\t|\u007c](.+)\r?\n viene interpretata come illustrato nella tabella seguente.

Modello	Oggetto di descrizione
\G	Iniziare la corrispondenza dalla posizione in cui termina l'ultima corrispondenza.
(.+)	Trovare la corrispondenza con qualsiasi carattere una o più volte. Equivale al primo gruppo di acquisizione.
[\t\u007c]	Trovare la corrispondenza con un carattere di tabulazione (\t) o una barra verticale (\|).
(.+)	Trovare la corrispondenza con qualsiasi carattere una o più volte. Equivale al secondo gruppo di acquisizione.
\r? \n	Trovare la corrispondenza con zero o una occorrenza di un ritorno a capo seguito da una nuova riga.

Vedere anche

Concetti

Elementi del linguaggio di espressioni regolari

Cronologia delle modifiche

Data	Cronologia	Motivo
Maggio 2010	È stato corretto il modello dell'espressione regolare.	Commenti e suggerimenti dei clienti.

Maggio 2010

È stato corretto il modello dell'espressione regolare.

Commenti e suggerimenti dei clienti.

Condividi tramite