Condividi tramite

Classi di caratteri

  • Articolo

Una classe di caratteri definisce un set di caratteri, di cui uno qualsiasi può verificarsi in una stringa di input per trovare una corrispondenza. Il linguaggio delle espressioni regolari di .NET Framework supporta le seguenti classi di caratteri:

  • Gruppo di caratteri positivi. Un carattere nella stringa di input deve corrispondere a un set di caratteri specificato. Per ulteriori informazioni, vedere Gruppo di caratteri positivi.

  • Gruppi di caratteri negativi. Un carattere nella stringa di input non deve corrispondere a un set di caratteri specificato. Per ulteriori informazioni, vedere Gruppo di caratteri negativi.

  • Qualsiasi carattere. Il carattere . (punto) in un'espressione regolare è un carattere jolly che corrisponde a qualsiasi carattere eccetto \n. Per ulteriori informazioni, vedere Qualsiasi carattere.

  • Una categoria generale Unicode o un blocco denominato. Per trovare una corrispondenza, un carattere nella stringa di input deve appartenere a una particolare categoria Unicode o deve essere compreso in un intervallo contiguo di caratteri Unicode. Per ulteriori informazioni, vedere Categoria Unicode negativa o blocco Unicode.

  • Una categoria negativa Unicode o un blocco denominato. Per trovare una corrispondenza, un carattere nella stringa di input non deve essere un membro di una particolare categoria Unicode o non deve essere compreso in un intervallo contiguo di caratteri Unicode. Per ulteriori informazioni, vedere Categoria Unicode negativa o blocco Unicode.

  • Carattere alfanumerico. Un carattere nella stringa di input può appartenere a qualsiasi categoria Unicode adatta per i caratteri alfabetici. Per ulteriori informazioni, vedere Carattere alfabetico.

  • Un carattere non alfabetico. Un carattere nella stringa di input può appartenere a qualsiasi categoria Unicode che non sia un carattere alfabetico. Per ulteriori informazioni, vedere Carattere non alfabetico.

  • Carattere di spazio vuoto. Un carattere nella stringa di input può essere qualsiasi carattere separatore Unicode, nonché un numero qualsiasi di caratteri di controllo. Per ulteriori informazioni, vedere Carattere di spazio vuoto.

  • Carattere diverso da uno spazio vuoto. Un carattere nella stringa di input può essere qualsiasi carattere che non è uno spazio vuoto. Per ulteriori informazioni, vedere Carattere diverso da uno spazio vuoto.

  • Una cifra decimale. Un carattere nella stringa di input può essere qualsiasi numero di caratteri classificato come cifre decimali Unicode. Per ulteriori informazioni, vedere Carattere decimale numerico.

  • Una cifra non decimale. Un carattere nella stringa di input può essere qualsiasi carattere tranne una cifra decimale Unicode. Per ulteriori informazioni, vedere Carattere decimale numerico.

.NET Framework supporta espressioni di sottrazione di classi di caratteri che consentono di definire un set di caratteri come risultato dell'esclusione di una classe di caratteri da un'altra classe di caratteri. Per ulteriori informazioni, vedere Sottrazione di classi di caratteri.

Gruppo di caratteri positivi: [ ]

Un gruppo di caratteri positivi specifica un elenco di caratteri che possono essere presenti in una stringa di input per trovare una corrispondenza. È possibile specificare l'elenco di caratteri in modo individuale, come intervallo o entrambi.

Di seguito viene indicata la sintassi per specificare un elenco di singoli caratteri:

[gruppo_caratteri]

dove gruppo_caratteri è un elenco dei singoli caratteri che possono apparire nella stringa di input affinché una corrispondenza riesca. gruppo_caratteri può contenere qualsiasi combinazione di uno o più caratteri letterali, caratteri di escape o classi di caratteri.

Di seguito viene indicata la sintassi per specificare un intervallo di caratteri:

[firstCharacter-lastCharacter]

dove firstCharacter è il carattere che inizia l'intervallo e lastCharacter è il carattere che termina l'intervallo. Un intervallo di caratteri è una serie contigua di caratteri definita specificando il primo carattere della serie, un trattino (-) e quindi l'ultimo carattere della serie. Due caratteri sono contigui se hanno punti di codice Unicode adiacenti.

Nella tabella seguente sono elencati alcuni modelli di espressioni regolari comuni contenenti classi di caratteri positivi.

Modello

Oggetto di descrizione

[aeiou]

Corrisponde a tutte le vocali.

[\p{P}\d]

Corrisponde a tutti i caratteri di punteggiatura eccetto le cifre decimali.

[\s\p{P}]

Corrisponde a tutti gli spazi vuoti e ai caratteri di punteggiatura.

Nell'esempio seguente viene definito un gruppo di caratteri positivi contenente i caratteri "a" ed "e" in modo che la stringa di input contenga obbligatoriamente le parole "grey" o "gray" seguite da un'altra parola perché si verifichi una corrispondenza.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "gr[ae]y\s\S+?[\s|\p{P}]"
      Dim input As String = "The gray wolf jumped over the grey wall."
      Dim matches As MatchCollection = Regex.Matches(input, pattern)
      For Each match As Match In matches
         Console.WriteLine(match.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       gray wolf
'       grey wall.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"gr[ae]y\s\S+?[\s|\p{P}]";
      string input = "The gray wolf jumped over the grey wall.";
      MatchCollection matches = Regex.Matches(input, pattern);
      foreach (Match match in matches)
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       gray wolf
//       grey wall.

L'espressione regolare gr[ae]y\s\S+?[\s|\p{P}] viene definita nel seguente modo:

Modello

Oggetto di descrizione

gr

Corrisponde ai caratteri letterali "gr".

[ae]

Corrisponde a una "a" o a una "e."

y\s

Corrisponde al carattere letterale "y" seguito da uno spazio vuoto.

\S+?

Corrisponde a uno o più caratteri di spazio vuoto, ma al minor numero di caratteri possibile.

[\s|\p{P}]

Corrisponde a un carattere di spazio vuoto o a un segno di punteggiatura.

Le corrispondenze dell'esempio seguente sono relative a parole che iniziano con una lettera maiuscola qualsiasi. Utilizza la sottoespressione [A-Z] per rappresentare l'intervallo di lettere maiuscole da A a Z.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b[A-Z]\w*\b"
      Dim input As String = "A city Albany Zulu maritime Marseilles"
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next
   End Sub
End Module

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[A-Z]\w*\b";
      string input = "A city Albany Zulu maritime Marseilles";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       A
//       Albany
//       Zulu
//       Marseilles

L'espressione regolare \b[A-Z]\w*\b viene definita come illustrato nella tabella riportata di seguito.

Modello

Oggetto di descrizione

\b

Iniziare dal confine di una parola.

[A-Z]

Corrisponde a qualsiasi carattere maiuscolo da A a Z.

\w*

Corrisponde a zero o più caratteri alfanumerici.

\b

Trovare la corrispondenza di un confine di parola.

Torna all'inizio

Gruppo di caratteri negativi: [^]

Un gruppo di caratteri negativi specifica un elenco di caratteri che non devono essere presenti in una stringa di input per trovare una corrispondenza. È possibile specificare l'elenco di caratteri in modo individuale, come intervallo o entrambi.

Di seguito viene indicata la sintassi per specificare un elenco di singoli caratteri:

[^gruppo_caratteri]

dove gruppo_caratteri è un elenco dei singoli caratteri che non possono apparire nella stringa di input affinché una corrispondenza riesca. gruppo_caratteri può contenere qualsiasi combinazione di uno o più caratteri letterali, caratteri di escape o classi di caratteri.

Di seguito viene indicata la sintassi per specificare un intervallo di caratteri:

[^primoCarattere-ultimoCarattere]

dove firstCharacter è il carattere che inizia l'intervallo e lastCharacter è il carattere che termina l'intervallo. Un intervallo di caratteri è una serie contigua di caratteri definita specificando il primo carattere della serie, un trattino (-) e quindi l'ultimo carattere della serie. Due caratteri sono contigui se hanno punti di codice Unicode adiacenti.

Due o più intervalli di caratteri possono essere concatenati. Ad esempio, per specificare l'intervallo di cifre decimali comprese tra '0' e '9', l'intervallo di lettere minuscole comprese tra 'a' e 'f' e l'intervallo di lettere maiuscole comprese tra 'A' e 'F', utilizzare [0-9a-fA-F].

L'accento circonflesso iniziale (^) in un gruppo di caratteri negativi è obbligatorio e indica che tale gruppo è un gruppo di caratteri negativi anziché un gruppo di caratteri positivi.

Nota importanteImportante

Un gruppo di caratteri negativi in un criterio di espressione regolare più grande non è un'asserzione a larghezza zero.Ovvero, dopo avere valutato il gruppo di caratteri negativo, il motore delle espressioni regolari avanza di un carattere nella stringa di input.

Nella tabella seguente sono elencati alcuni modelli di espressioni regolari comuni contenenti gruppi di caratteri negativi.

Modello

Oggetto di descrizione

[^aeiou]

Corrisponde a tutti i caratteri eccetto le vocali.

[^\p{P}\d]

Corrisponde a tutti i caratteri eccetto caratteri di punteggiatura e cifre decimali.

Le corrispondenze dell'esempio seguente sono relative a tutte le parole che iniziano con i caratteri "th" e non sono seguite dalla lettera "o".

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\bth[^o]\w+\b"
      Dim input As String = "thought thing though them through thus " + _
                            "thorough this"
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       thing
'       them
'       through
'       thus
'       this

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\bth[^o]\w+\b";
      string input = "thought thing though them through thus thorough this";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       thing
//       them
//       through
//       thus
//       this

L'espressione regolare \bth[^o]\w+\b viene definita come illustrato nella tabella riportata di seguito.

Modello

Oggetto di descrizione

\b

Iniziare dal confine di una parola.

th

Corrisponde ai caratteri letterali "th".

[^o]

Corrisponde a tutti i caratteri diversi da "o".

\w+

Trovare la corrispondenza di uno o più caratteri alfanumerici.

\b

Terminare al confine di una parola.

Torna all'inizio

Qualsiasi carattere: .

Il carattere punto (.) corrisponde a qualsiasi carattere eccetto \n (carattere di nuova riga, \u000A), con le due qualificazioni seguenti:

  • Se un criterio di espressione regolare viene modificato dall'opzione RegexOptions.Singleline o se la parte del criterio contenente la classe di caratteri . viene modificata dall'opzione s, . corrisponde a qualsiasi carattere. Per ulteriori informazioni, vedere Opzioni di espressioni regolari.

    Nell'esempio seguente viene illustrato il diverso comportamento della classe di caratteri . per impostazione predefinita e con l'opzione RegexOptions.Singleline. L'espressione regolare ^.+ parte dall'inizio della stringa e individua una corrispondenza per ogni carattere. Per impostazione predefinita, la corrispondenza termina alla fine della prima riga; il criterio di espressione regolare corrisponde al carattere di ritorno a capo, \r o \u000D, ma non corrisponde a \n. Poiché l'opzione RegexOptions.Singleline interpreta la stringa di input intera come sola riga, ottiene una corrispondenza per ogni carattere nella stringa di input, incluso \n.

    Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "^.+"
      Dim input As String = "This is one line and" + vbCrLf + "this is the second."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(Regex.Escape(match.Value))
      Next
      Console.WriteLine()
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.SingleLine)
         Console.WriteLine(Regex.Escape(match.Value))
      Next
   End Sub
End Module
' The example displays the following output:
'       This\ is\ one\ line\ and\r
'       
'       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.

    using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "^.+";
      string input = "This is one line and" + Environment.NewLine + "this is the second.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(Regex.Escape(match.Value));

      Console.WriteLine();
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Singleline))
         Console.WriteLine(Regex.Escape(match.Value));
   }
}
// The example displays the following output:
//       This\ is\ one\ line\ and\r
//       
//       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
NotaNota

Poiché corrisponde a qualsiasi carattere eccetto \n, la classe di caratteri . corrisponde anche a \r (il carattere del ritorno a capo, \u000D).

  • In un gruppo di caratteri positivi o negativi, un punto viene interpretato come carattere punto letterale e non come classe di caratteri. Per ulteriori informazioni, vedere Gruppo di caratteri positivi e Gruppo di caratteri negativi descritti più indietro in questo argomento. Nell'esempio seguente viene fornita un'illustrazione mediante la definizione di un'espressione regolare che include il carattere punto (.) sia come classe di caratteri che come membro di un gruppo di caratteri positivi. L'espressione regolare \b.*[.?!;:](\s|\z) inizia in corrispondenza della fine di una parola, corrisponde a qualsiasi carattere fino a quando non incontra uno dei quattro segni di punteggiatura, incluso un punto, quindi individua la corrispondenza con un carattere di spazio vuoto o con la fine della stringa.

    Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As STring = "\b.*[.?!;:](\s|\z)"
      Dim input As String = "this. what: is? go, thing."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next   
   End Sub
End Module
' The example displays the following output:
'       this. what: is? go, thing.

    using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b.*[.?!;:](\s|\z)";
      string input = "this. what: is? go, thing.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       this. what: is? go, thing.
NotaNota

Poiché corrisponde a qualsiasi carattere, l'elemento di linguaggio . spesso è utilizzato con un quantificatore lazy se un criterio di espressione regolare tenta di ottenere una corrispondenza di ogni carattere più volte.Per ulteriori informazioni, vedere Quantificatori.

Torna all'inizio

Categoria Unicode negativa o blocco Unicode: \p{}}

Lo standard Unicode assegna una categoria generale a ogni carattere. Ad esempio, un carattere particolare può essere una lettera maiuscola (rappresentata dalla categoria Lu), un numero decimale (la categoria Nd), un simbolo matematico (la categoria Sm) o un separatore di paragrafo (la categoria Zl). Anche i set di caratteri specifici nello standard Unicode occupano un intervallo specifico o un blocco di punti di codice consecutivi. Il set di caratteri latini ad esempio si trova da \u0000 a \u007F, mentre il set di caratteri arabi si trova da \u0600 a \u06FF.

Costrutto dell'espressione regolare

\p{name}

corrisponde a qualsiasi carattere appartenente a una categoria generale Unicode o a un blocco denominato, dove name è l'abbreviazione della categoria o il nome del blocco denominato. Per un elenco delle abbreviazioni della categoria, vedere la sezione Categorie generali Unicode supportate riportata più avanti in questo argomento. Per un elenco dei blocchi denominati, vedere la sezione Blocchi denominati supportati riportata più avanti in questo argomento.

L'esempio seguente utilizza il costrutto \p{nome} per individuare una corrispondenza per una categoria generale Unicode (in questo caso, Pd o categoria Punctuation, Dash) e un blocco denominato (i blocchi denominati IsGreek e IsBasicLatin).

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+"
      Dim input As String = "Κατα Μαθθαίον - The Gospel of Matthew"

      Console.WriteLine(Regex.IsMatch(input, pattern))         ' Displays True.
   End Sub
End Module

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+";
      string input = "Κατα Μαθθαίον - The Gospel of Matthew";

      Console.WriteLine(Regex.IsMatch(input, pattern));        // Displays True.
   }
}

L'espressione regolare \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ viene definita come illustrato nella tabella riportata di seguito.

Modello

Oggetto di descrizione

\b

Iniziare dal confine di una parola.

\p{IsGreek}+

Corrisponde a uno o più caratteri greci.

(\s)?

Ricerca la corrispondenza di zero o di un carattere spazio vuoto.

(\p{IsGreek}+(\s)?)+

Ottiene una o più volte la corrispondenza con il modello di uno o più caratteri greci seguiti da zero o da uno spazio vuoto.

\p{Pd}

Corrisponde a un carattere "Pd" (punctuation, dash).

\s

Trovare la corrispondenza di uno spazio vuoto.

\p{IsBasicLatin}+

Corrisponde a uno o più caratteri latini di base.

(\s)?

Ricerca la corrispondenza di zero o di un carattere spazio vuoto.

(\p{IsBasicLatin}+(\s)?)+

Ottiene una o più volte la corrispondenza con il modello di uno o più caratteri latini di base seguiti da zero o da uno spazio vuoto.

Torna all'inizio

Categoria Unicode negativa o blocco Unicode: \P {}

Lo standard Unicode assegna una categoria generale a ogni carattere. Ad esempio, un carattere particolare può essere una lettera maiuscola (rappresentata dalla categoria Lu), un numero decimale (la categoria Nd), un simbolo matematico (la categoria Sm) o un separatore di paragrafo (la categoria Zl). Anche i set di caratteri specifici nello standard Unicode occupano un intervallo specifico o un blocco di punti di codice consecutivi. Il set di caratteri latini ad esempio si trova da \u0000 a \u007F, mentre il set di caratteri arabi si trova da \u0600 a \u06FF.

Costrutto dell'espressione regolare

\P{name}

corrisponde a qualsiasi carattere non appartenente a una categoria generale Unicode o a un blocco denominato, dove name è l'abbreviazione della categoria o il nome del blocco denominato. Per un elenco delle abbreviazioni della categoria, vedere la sezione Categorie generali Unicode supportate riportata più avanti in questo argomento. Per un elenco dei blocchi denominati, vedere la sezione Blocchi denominati supportati riportata più avanti in questo argomento.

L'esempio seguente utilizza il costrutto nome \P{} per rimuovere eventuali simboli di valuta (in questo caso, Sc o la categoria Symbol, Currency) dalle stringhe numeriche.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\P{Sc})+"

      Dim values() As String = { "$164,091.78", "£1,073,142.68", "73¢", "€120"}
      For Each value As String In values
         Console.WriteLine(Regex.Match(value, pattern).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       164,091.78
'       1,073,142.68
'       73
'       120

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\P{Sc})+";

      string[] values = { "$164,091.78", "£1,073,142.68", "73¢", "€120" };
      foreach (string value in values)
         Console.WriteLine(Regex.Match(value, pattern).Value);
   }
}
// The example displays the following output:
//       164,091.78
//       1,073,142.68
//       73
//       120

Il modello dell'espressione regolare (\P{Sc})+ corrisponde a uno o più caratteri che non siano simboli di valuta e rimuove efficacemente qualsiasi simbolo di valuta dalla stringa di risultato.

Torna all'inizio

Carattere alfabetico: \w

\w corrisponde a qualsiasi carattere alfabetico. Un carattere alfanumerico è un membro di una delle categorie Unicode elencate nella seguente tabella.

Category

Oggetto di descrizione

Ll

Letter, Lowercase

Lu

Letter, Uppercase

Lt

Letter, Titlecase

Lo

Letter, Other

Lm

Letter, Modifier

Nd

Number, Decimal Digit

Pc

Punteggiatura, di collegamento. Questa categoria include dieci caratteri, tra cui quello più comunemente utilizzato è (_) LOWLINE, u+005F.

Se viene specificato il comportamento conforme a ECMAScript, \w equivale a [a-zA-Z_0-9]. Per informazioni sulle espressioni regolari ECMAScript, vedere la sezione "Comportamento della corrispondenza ECMAScript " in Opzioni di espressioni regolari.

NotaNota

Poiché corrisponde a qualsiasi carattere alfanumerico, l'elemento di linguaggio \w spesso è utilizzato con un quantificatore lazy se un criterio di espressione regolare tenta di ottenere più volte una corrispondenza di ogni carattere alfanumerico, seguito da un carattere alfanumerico specifico.Per ulteriori informazioni, vedere Quantificatori.

Nell'esempio seguente viene utilizzato l'elemento di linguaggio \w per individuare una corrispondenza con i caratteri duplicati in una parola. L'esempio definisce un modello di espressione regolare, (\w)\1, che può essere interpretato nel modo seguente.

Elemento

Oggetto di descrizione

(\w)

Corrisponde a un carattere alfabetico. Equivale al primo gruppo di acquisizione.

\1

Corrisponde al valore della prima acquisizione.

 
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\w)\1"
      Dim words() As String = { "trellis", "seer", "latter", "summer", _
                                "hoarse", "lesser", "aardvark", "stunned" }
      For Each word As String In words
         Dim match As Match = Regex.Match(word, pattern)
         If match.Success Then
            Console.WriteLine("'{0}' found in '{1}' at position {2}.", _
                              match.Value, word, match.Index)
         Else
            Console.WriteLine("No double characters in '{0}'.", word)
         End If
      Next                                                  
   End Sub
End Module
' The example displays the following output:
'       'll' found in 'trellis' at position 3.
'       'ee' found in 'seer' at position 1.
'       'tt' found in 'latter' at position 2.
'       'mm' found in 'summer' at position 2.
'       No double characters in 'hoarse'.
'       'ss' found in 'lesser' at position 2.
'       'aa' found in 'aardvark' at position 0.
'       'nn' found in 'stunned' at position 3.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\w)\1";
      string[] words = { "trellis", "seer", "latter", "summer", 
                         "hoarse", "lesser", "aardvark", "stunned" };
      foreach (string word in words)
      {
         Match match = Regex.Match(word, pattern);
         if (match.Success)
            Console.WriteLine("'{0}' found in '{1}' at position {2}.", 
                              match.Value, word, match.Index);
         else
            Console.WriteLine("No double characters in '{0}'.", word);
      }                                                  
   }
}
// The example displays the following output:
//       'll' found in 'trellis' at position 3.
//       'ee' found in 'seer' at position 1.
//       'tt' found in 'latter' at position 2.
//       'mm' found in 'summer' at position 2.
//       No double characters in 'hoarse'.
//       'ss' found in 'lesser' at position 2.
//       'aa' found in 'aardvark' at position 0.
//       'nn' found in 'stunned' at position 3.

Torna all'inizio

Carattere non alfabetico: \W

\W corrisponde a qualsiasi carattere non alfabetico. L'elemento di linguaggio \W è equivalente alla classe di caratteri seguente:

[^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]

In altre parole, corrisponde a tutti i caratteri, ad eccezione di quelli elencati nella tabella seguente.

Category

Oggetto di descrizione

Ll

Letter, Lowercase

Lu

Letter, Uppercase

Lt

Letter, Titlecase

Lo

Letter, Other

Lm

Letter, Modifier

Nd

Number, Decimal Digit

Pc

Punteggiatura, di collegamento. Questa categoria include dieci caratteri, tra cui quello più comunemente utilizzato è (_) LOWLINE, u+005F.

Se viene specificato il comportamento conforme a ECMAScript, \W equivale a [^a-zA-Z_0-9]. Per informazioni sulle espressioni regolari ECMAScript, vedere la sezione "Comportamento della corrispondenza ECMAScript " in Opzioni di espressioni regolari.

NotaNota

Poiché corrisponde a qualsiasi carattere non alfanumerico, l'elemento di linguaggio \W spesso è utilizzato con un quantificatore lazy se un criterio di espressione regolare tenta di ottenere più volte una corrispondenza di ogni carattere non alfanumerico, seguito da un carattere non alfanumerico specifico.Per ulteriori informazioni, vedere Quantificatori.

Nell'esempio seguente viene illustrata la classe di caratteri \w. Definisce un criterio di espressione regolare, \b(\w+)(\W){1,2}, che corrisponde a una parola seguita da uno o più caratteri non alfabetici, ad esempio uno spazio vuoto o un segno di punteggiatura. L'espressione regolare viene interpretata come illustrato nella tabella seguente.

Elemento

Oggetto di descrizione

\b

Inizia la corrispondenza sul confine di parola.

(\w+)

Trovare la corrispondenza di uno o più caratteri alfanumerici. Equivale al primo gruppo di acquisizione.

(\w){1,2}

Ottiene una o due volte una corrispondenza di un carattere non alfanumerico. Equivale al secondo gruppo di acquisizione.

 
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(\w+)(\W){1,2}"
      Dim input As String = "The old, grey mare slowly walked across the narrow, green pasture."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
         Console.Write("   Non-word character(s):")
         Dim captures As CaptureCollection = match.Groups(2).Captures
         For ctr As Integer = 0 To captures.Count - 1
             Console.Write("'{0}' (\u{1}){2}", captures(ctr).Value, _
                           Convert.ToUInt16(captures(ctr).Value.Chars(0)).ToString("X4"), _
                           If(ctr < captures.Count - 1, ", ", ""))
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'       The
'          Non-word character(s):' ' (\u0020)
'       old,
'          Non-word character(s):',' (\u002C), ' ' (\u0020)
'       grey
'          Non-word character(s):' ' (\u0020)
'       mare
'          Non-word character(s):' ' (\u0020)
'       slowly
'          Non-word character(s):' ' (\u0020)
'       walked
'          Non-word character(s):' ' (\u0020)
'       across
'          Non-word character(s):' ' (\u0020)
'       the
'          Non-word character(s):' ' (\u0020)
'       narrow,
'          Non-word character(s):',' (\u002C), ' ' (\u0020)
'       green
'          Non-word character(s):' ' (\u0020)
'       pasture.
'          Non-word character(s):'.' (\u002E)

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\w+)(\W){1,2}";
      string input = "The old, grey mare slowly walked across the narrow, green pasture.";
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine(match.Value);
         Console.Write("   Non-word character(s):");
         CaptureCollection captures = match.Groups[2].Captures;
         for (int ctr = 0; ctr < captures.Count; ctr++)
             Console.Write(@"'{0}' (\u{1}){2}", captures[ctr].Value, 
                           Convert.ToUInt16(captures[ctr].Value[0]).ToString("X4"), 
                           ctr < captures.Count - 1 ? ", " : "");
         Console.WriteLine();
      }   
   }
}
// The example displays the following output:
//       The
//          Non-word character(s):' ' (\u0020)
//       old,
//          Non-word character(s):',' (\u002C), ' ' (\u0020)
//       grey
//          Non-word character(s):' ' (\u0020)
//       mare
//          Non-word character(s):' ' (\u0020)
//       slowly
//          Non-word character(s):' ' (\u0020)
//       walked
//          Non-word character(s):' ' (\u0020)
//       across
//          Non-word character(s):' ' (\u0020)
//       the
//          Non-word character(s):' ' (\u0020)
//       narrow,
//          Non-word character(s):',' (\u002C), ' ' (\u0020)
//       green
//          Non-word character(s):' ' (\u0020)
//       pasture.
//          Non-word character(s):'.' (\u002E)

Poiché l'oggetto Group per il secondo gruppo di acquisizione contiene un solo carattere non alfanumerico acquisito, l'esempio recupera tutti i caratteri non alfanumerici acquisiti dall'oggetto CaptureCollection restituito dalla proprietà Group.Captures.

Torna all'inizio

Carattere di spazio vuoto: \s

\s corrisponde a qualsiasi carattere di spazio vuoto. È equivalente alle sequenze di escape e alle categorie Unicode elencate nella tabella seguente.

Category

Oggetto di descrizione

\f

Carattere di avanzamento modulo, \u000C.

\n

Carattere di nuova riga, \u000A.

\r

Carattere di ritorno a capo, \u000D.

\t

Carattere di tabulazione, \u0009.

\v

Carattere di tabulazione verticale, \u000B.

\x85

Puntini di sospensione o carattere NEXT LINE (NEL) (...), \u0085.

\p{Z}

Corrisponde a qualsiasi carattere separatore.

Se viene specificato il comportamento conforme a ECMAScript, \s equivale a [\f\n\r\t\v]. Per informazioni sulle espressioni regolari ECMAScript, vedere la sezione "Comportamento della corrispondenza ECMAScript " in Opzioni di espressioni regolari.

Nell'esempio seguente viene illustrata la classe di caratteri \s. Definisce un modello di espressione regolare, \b\w+(e)*s(\s|$), che corrisponde a una parola che termina in "s" o "es" seguita da uno spazio vuoto o dalla fine della stringa di input. L'espressione regolare viene interpretata come illustrato nella tabella seguente.

Elemento

Oggetto di descrizione

\b

Inizia la corrispondenza sul confine di parola.

\w+

Trovare la corrispondenza di uno o più caratteri alfanumerici.

(e)*

Ottiene zero o una volta la corrispondenza di una "e".

s

Corrisponde a una "s".

(\s|$)

Corrisponde a uno spazio vuoto o alla fine della stringa di input.

 
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+(e)*s(\s|$)"
      Dim input As String = "matches stores stops leave leaves"
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)      
      Next
   End Sub
End Module
' The example displays the following output:
'       matches
'       stores
'       stops
'       leaves

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+(e)*s(\s|$)";
      string input = "matches stores stops leave leaves";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       matches
//       stores
//       stops
//       leaves

Torna all'inizio

Carattere diverso da uno spazio vuoto: \S

\S corrisponde a qualsiasi carattere diverso da uno spazio vuoto. È equivalente al modello di espressione regolare [^\f\n\r\t\v\x85\p{Z}] o è il contrario del modello di espressione regolare equivalente a \s, che corrisponde a caratteri di spazio vuoto. Per ulteriori informazioni, vedere Carattere di spazio vuoto: \s.

Se viene specificato il comportamento conforme a ECMAScript, \S equivale a [^ \f\n\r\t\v]. Per informazioni sulle espressioni regolari ECMAScript, vedere la sezione "Comportamento della corrispondenza ECMAScript " in Opzioni di espressioni regolari.

Nell'esempio seguente viene illustrato l'elemento di linguaggio \S. Il modello dell'espressione regolare \b(\S+)\s* corrisponde a stringhe delimitate da caratteri di spazio vuoto. Il secondo elemento nell'oggetto GroupCollection della corrispondenza contiene la stringa corrispondente. L'espressione regolare può essere interpretata come illustrato nella tabella seguente.

Elemento

Oggetto di descrizione

\b

Inizia la corrispondenza sul confine di parola.

(\S+)

Corrisponde a uno o più caratteri di spazio vuoto. Equivale al primo gruppo di acquisizione.

\s*

Ricerca la corrispondenza di zero o di un carattere spazio vuoto.

 
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(\S+)\s*"
      Dim input As String = "This is the first sentence of the first paragraph. " + _
                            "This is the second sentence." + vbCrLf + _
                            "This is the only sentence of the second paragraph."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Groups(1))
      Next
   End Sub
End Module
' The example displays the following output:
'    This
'    is
'    the
'    first
'    sentence
'    of
'    the
'    first
'    paragraph.
'    This
'    is
'    the
'    second
'    sentence.
'    This
'    is
'    the
'    only
'    sentence
'    of
'    the
'    second
'    paragraph.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\S+)\s*";
      string input = "This is the first sentence of the first paragraph. " + 
                            "This is the second sentence.\n" + 
                            "This is the only sentence of the second paragraph.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Groups[1]);
   }
}
// The example displays the following output:
//    This
//    is
//    the
//    first
//    sentence
//    of
//    the
//    first
//    paragraph.
//    This
//    is
//    the
//    second
//    sentence.
//    This
//    is
//    the
//    only
//    sentence
//    of
//    the
//    second
//    paragraph.

Torna all'inizio

Carattere decimale numerico: \d

\d corrisponde a qualsiasi cifra decimale. È equivalente al modello di espressione regolare \p{Nd} che include le cifre decimali standard 0-9 e le cifre decimali di un numero di altri set di caratteri.

Se viene specificato il comportamento conforme a ECMAScript, \d equivale a [0-9]. Per informazioni sulle espressioni regolari ECMAScript, vedere la sezione "Comportamento della corrispondenza ECMAScript " in Opzioni di espressioni regolari.

Nell'esempio seguente viene illustrato l'elemento di linguaggio \d. Verifica se una stringa di input rappresenta un numero di telefono valido negli Stati Uniti e in Canada. Il modello di espressione regolare ^(\(*\d{3}\)*[\s-])*\d{3}-\d{4}$ viene definito come illustrato nella tabella seguente.

Elemento

Oggetto di descrizione

^

Inizia la corrispondenza all'inizio della stringa di input.

\(*

Corrisponde a zero o un carattere letterale "(".

\d{3}

Corrisponde a tre cifre decimali.

\)*

Corrisponde a zero o un carattere letterale ")".

[\s-]

Corrisponde a un trattino o a un carattere di spazio vuoto.

(\(*\d{3}\)*[\s-])*

Ottiene la corrispondenza zero o una volta di una parentesi di apertura facoltativa seguita da tre cifre decimali, una parentesi di chiusura facoltativa e un carattere di spazio vuoto o un trattino. Equivale al primo gruppo di acquisizione.

\d{3}=\d{4}

Corrisponde a tre cifre decimali seguite da un trattino e da altre quattro cifre decimali.

$

Corrisponde alla fine della stringa di input.

 
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "^(\(*\d{3}\)*[\s-])*\d{3}-\d{4}$"
      Dim inputs() As String = { "111 111-1111", "222-2222", "222 333-444", _
                                 "(212) 111-1111", "111-AB1-1111", _
                                 "212-111-1111", "01 999-9999" }

      For Each input As String In inputs
         If Regex.IsMatch(input, pattern) Then 
            Console.WriteLine(input + ": matched")
         Else
            Console.WriteLine(input + ": match failed")
         End If   
      Next
   End Sub
End Module
' The example displays the following output:
'       111 111-1111: matched
'       222-2222: matched
'       222 333-444: match failed
'       (212) 111-1111: matched
'       111-AB1-1111: match failed
'       212-111-1111: matched
'       01 999-9999: match failed

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"^(\(*\d{3}\)*[\s-])*\d{3}-\d{4}$";
      string[] inputs = { "111 111-1111", "222-2222", "222 333-444", 
                          "(212) 111-1111", "111-AB1-1111", 
                          "212-111-1111", "01 999-9999" };

      foreach (string input in inputs)
      {
         if (Regex.IsMatch(input, pattern)) 
            Console.WriteLine(input + ": matched");
         else
            Console.WriteLine(input + ": match failed");
      }
   }
}
// The example displays the following output:
//       111 111-1111: matched
//       222-2222: matched
//       222 333-444: match failed
//       (212) 111-1111: matched
//       111-AB1-1111: match failed
//       212-111-1111: matched
//       01 999-9999: match failed

Torna all'inizio

Carattere non numerico: \D

\D corrisponde a qualsiasi carattere non numerico. È equivalente al modello di espressione regolare \p{Nd}.

Se viene specificato il comportamento conforme a ECMAScript, \D equivale a [^0-9]. Per informazioni sulle espressioni regolari ECMAScript, vedere la sezione "Comportamento della corrispondenza ECMAScript " in Opzioni di espressioni regolari.

Nell'esempio seguente viene illustrato l'elemento di linguaggio \D. Verifica se una stringa, ad esempio un numero parte, è formata dalla combinazione corretta di caratteri decimali e non decimali. Il modello di espressione regolare ^\D\d{1,5}\D*$ viene definito come illustrato nella tabella seguente.

Elemento

Oggetto di descrizione

^

Inizia la corrispondenza all'inizio della stringa di input.

\D

Corrisponde a un carattere non numerico.

\d{1,5}

Corrisponde da una a cinque cifre decimali.

\D*

Corrisponde a zero o un carattere non decimale.

$

Corrisponde alla fine della stringa di input.

 
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "^\D\d{1,5}\D*$" 
      Dim inputs() As String = { "A1039C", "AA0001", "C18A", "Y938518" } 

      For Each input As String In inputs
         If Regex.IsMatch(input, pattern) Then
            Console.WriteLine(input + ": matched")
         Else
            Console.WriteLine(input + ": match failed")
         End If   
      Next
   End Sub
End Module
' The example displays the following output:

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"^\D\d{1,5}\D*$"; 
      string[] inputs = { "A1039C", "AA0001", "C18A", "Y938518" }; 

      foreach (string input in inputs)
      {
         if (Regex.IsMatch(input, pattern))
            Console.WriteLine(input + ": matched");
         else
            Console.WriteLine(input + ": match failed");
      }
   }
}
// The example displays the following output:
//       A1039C: matched
//       AA0001: match failed
//       C18A: matched
//       Y938518: match failed

Torna all'inizio

Categorie generali Unicode supportate

In Unicode sono definite le categorie generali elencate nella tabella riportata di seguito. Per ulteriori informazioni, vedere le sezioni relative al formato di file UCD e ai valori delle categorie generali in Database dei caratteri Unicode (informazioni in lingua inglese).

Category

Oggetto di descrizione

Lu

Letter, Uppercase

Ll

Letter, Lowercase

Lt

Letter, Titlecase

Lm

Letter, Modifier

Lo

Letter, Other

L

Tutti i caratteri alfabetici. Ciò include i caratteri Lu, Ll, Lt, Lm e Lo.

Mn

Mark, Nonspacing

Mc

Mark, Spacing Combining

Me

Mark, Enclosing

M

Tutti i contrassegni diacritici. Ciò include le categorie Mn, Mc e Me.

Nd

Number, Decimal Digit

Nl

Number, Letter

No

Number, Other

N

Tutti i numeri. Ciò include le categorie Nd, Nl e No.

Pc

Punctuation, Connector

Pd

Punctuation, Dash

Ps

Punctuation, Open

Pe

Punctuation, Close

Pi

Punctuation, Initial quote (può comportarsi come Ps o Pe a seconda dell'utilizzo)

Pf

Punctuation, Final quote (può comportarsi come Ps o Pe a seconda dell'utilizzo)

Po

Punctuation, Other

P

Tutti i caratteri di punteggiatura. Ciò include le categorie Pc, Pd, Ps, Pe, Pi, Pf e Po.

Sm

Symbol, Math

Sc

Symbol, Currency

Sk

Symbol, Modifier

So

Symbol, Other

S

Tutti i simboli. Ciò include le categorie Sm, Sc, Sk e So.

Zs

Separator, Space

Zl

Separator, Line

Zp

Separator, Paragraph

Z

Tutti i caratteri separatori. Ciò include le categorie Zs, Zl e Zp.

Cc

Other, Control

Cf

Other, Format

Cs

Other, Surrogate

Co

Other, Private Use

Cn

Other, Not Assigned (nessun carattere ha questa proprietà)

C

Tutti i caratteri di controllo. Ciò include le categorie Cc, Cf, Cs, Co e Cn.

È possibile determinare la categoria Unicode di qualsiasi particolare carattere passando quel carattere al metodo GetUnicodeCategory. L'esempio seguente utilizza il metodo GetUnicodeCategory per determinare la categoria di ogni elemento in un array che contiene caratteri latini selezionati.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim chars() As Char = { "a"c, "X"c, "8"c, ","c, " "c, ChrW(9), "!"c }

      For Each ch As Char In chars
         Console.WriteLine("'{0}': {1}", Regex.Escape(ch.ToString()), _
                           Char.GetUnicodeCategory(ch))
      Next         
   End Sub
End Module
' The example displays the following output:
'       'a': LowercaseLetter
'       'X': UppercaseLetter
'       '8': DecimalDigitNumber
'       ',': OtherPunctuation
'       '\ ': SpaceSeparator
'       '\t': Control
'       '!': OtherPunctuation

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      char[] chars = { 'a', 'X', '8', ',', ' ', '\u0009', '!' };

      foreach (char ch in chars)
         Console.WriteLine("'{0}': {1}", Regex.Escape(ch.ToString()), 
                           Char.GetUnicodeCategory(ch));
   }
}
// The example displays the following output:
//       'a': LowercaseLetter
//       'X': UppercaseLetter
//       '8': DecimalDigitNumber
//       ',': OtherPunctuation
//       '\ ': SpaceSeparator
//       '\t': Control
//       '!': OtherPunctuation

Torna all'inizio

Blocchi denominati supportati

.NET Framework fornisce i blocchi denominati elencati nella tabella riportata di seguito. Il set di blocchi denominati supportati è basato su Unicode 4.0 e Perl 5.6.

Intervallo di punti di codice

Nome del blocco

0000 - 007F

IsBasicLatin

0080 - 00FF

IsLatin-1Supplement

0100 - 017F

IsLatinExtended-A

0180 - 024F

IsLatinExtended-B

0250 - 02AF

IsIPAExtensions

02B0 - 02FF

IsSpacingModifierLetters

0300 - 036F

IsCombiningDiacriticalMarks

0370 - 03FF

IsGreek

In alternativa

IsGreekandCoptic

0400 - 04FF

IsCyrillic

0500 - 052F

IsCyrillicSupplement

0530 - 058F

IsArmenian

0590 - 05FF

IsHebrew

0600 - 06FF

IsArabic

0700 - 074F

IsSyriac

0780 - 07BF

IsThaana

0900 - 097F

IsDevanagari

0980 - 09FF

IsBengali

0A00 - 0A7F

IsGurmukhi

0A80 - 0AFF

IsGujarati

0B00 - 0B7F

IsOriya

0B80 - 0BFF

IsTamil

0C00 - 0C7F

IsTelugu

0C80 - 0CFF

IsKannada

0D00 - 0D7F

IsMalayalam

0D80 - 0DFF

IsSinhala

0E00 - 0E7F

IsThai

0E80 - 0EFF

IsLao

0F00 - 0FFF

IsTibetan

1000 - 109F

IsMyanmar

10A0 - 10FF

IsGeorgian

1100 - 11FF

IsHangulJamo

1200 - 137F

IsEthiopic

13A0 - 13FF

IsCherokee

1400 - 167F

IsUnifiedCanadianAboriginalSyllabics

1680 - 169F

IsOgham

16A0 - 16FF

IsRunic

1700 - 171F

IsTagalog

1720 - 173F

IsHanunoo

1740 - 175F

IsBuhid

1760 - 177F

IsTagbanwa

1780 - 17FF

IsKhmer

1800 - 18AF

IsMongolian

1900 - 194F

IsLimbu

1950 - 197F

IsTaiLe

19E0 - 19FF

IsKhmerSymbols

1D00 - 1D7F

IsPhoneticExtensions

1E00 - 1EFF

IsLatinExtendedAdditional

1F00 - 1FFF

IsGreekExtended

2000 - 206F

IsGeneralPunctuation

2070 - 209F

IsSuperscriptsandSubscripts

20A0 - 20CF

IsCurrencySymbols

20D0 - 20FF

IsCombiningDiacriticalMarksforSymbols

In alternativa

IsCombiningMarksforSymbols

2100 - 214F

IsLetterlikeSymbols

2150 - 218F

IsNumberForms

2190 - 21FF

IsArrows

2200 - 22FF

IsMathematicalOperators

2300 - 23FF

IsMiscellaneousTechnical

2400 - 243F

IsControlPictures

2440 - 245F

IsOpticalCharacterRecognition

2460 - 24FF

IsEnclosedAlphanumerics

2500 - 257F

IsBoxDrawing

2580 - 259F

IsBlockElements

25A0 - 25FF

IsGeometricShapes

2600 - 26FF

IsMiscellaneousSymbols

2700 - 27BF

IsDingbats

27C0 - 27EF

IsMiscellaneousMathematicalSymbols-A

27F0 - 27FF

IsSupplementalArrows-A

2800 - 28FF

IsBraillePatterns

2900 - 297F

IsSupplementalArrows-B

2980 - 29FF

IsMiscellaneousMathematicalSymbols-B

2A00 - 2AFF

IsSupplementalMathematicalOperators

2B00 - 2BFF

IsMiscellaneousSymbolsandArrows

2E80 - 2EFF

IsCJKRadicalsSupplement

2F00 - 2FDF

IsKangxiRadicals

2FF0 - 2FFF

IsIdeographicDescriptionCharacters

3000 - 303F

IsCJKSymbolsandPunctuation

3040 - 309F

IsHiragana

30A0 - 30FF

IsKatakana

3100 - 312F

IsBopomofo

3130 - 318F

IsHangulCompatibilityJamo

3190 - 319F

IsKanbun

31A0 - 31BF

IsBopomofoExtended

31F0 - 31FF

IsKatakanaPhoneticExtensions

3200 - 32FF

IsEnclosedCJKLettersandMonths

3300 - 33FF

IsCJKCompatibility

3400 - 4DBF

IsCJKUnifiedIdeographsExtensionA

4DC0 - 4DFF

IsYijingHexagramSymbols

4E00 - 9FFF

IsCJKUnifiedIdeographs

A000 - A48F

IsYiSyllables

A490 - A4CF

IsYiRadicals

AC00 - D7AF

IsHangulSyllables

D800 - DB7F

IsHighSurrogates

DB80 - DBFF

IsHighPrivateUseSurrogates

DC00 - DFFF

IsLowSurrogates

E000 - F8FF

IsPrivateUse oppure IsPrivateUseArea

F900 - FAFF

IsCJKCompatibilityIdeographs

FB00 - FB4F

IsAlphabeticPresentationForms

FB50 - FDFF

IsArabicPresentationForms-A

FE00 - FE0F

IsVariationSelectors

FE20 - FE2F

IsCombiningHalfMarks

FE30 - FE4F

IsCJKCompatibilityForms

FE50 - FE6F

IsSmallFormVariants

FE70 - FEFF

IsArabicPresentationForms-B

FF00 - FFEF

IsHalfwidthandFullwidthForms

FFF0 - FFFF

IsSpecials

Torna all'inizio

Sottrazione di classi di caratteri

Una classe di caratteri definisce un set di caratteri. La sottrazione di classi di caratteri produce un set di caratteri che è il risultato dell'esclusione dei caratteri di una classe di caratteri da un'altra classe di caratteri.

Un'espressione di sottrazione di classi di caratteri ha il formato seguente:

[gruppo_base-[gruppo_escluso]]

Le parentesi quadre ([]) e il trattino (-) sono obbligatori. Il gruppo_base è un gruppo di caratteri positivi o negativi descritto nella tabella Sintassi delle classi di caratteri. Il componente gruppo_escluso è un altro gruppo di caratteri positivi o negativi o un'altra espressione di sottrazione di classi di caratteri, ovvero è possibile annidare espressioni di sottrazione di classi di caratteri.

Si supponga ad esempio di disporre di un gruppo di base costituito dall'intervallo di caratteri compresi tra "a" e "z". Per definire il set di caratteri costituito dal gruppo di base con l'esclusione del carattere "m", utilizzare [a-z-[m]]. Per definire il set di caratteri costituito dal gruppo di base con l'esclusione del set di caratteri "d", "j" e "p", utilizzare [a-z-[djp]]. Per definire il set di caratteri costituito dal gruppo di base con l'esclusione dell'intervallo di caratteri compresi tra "m" e "p", utilizzare [a-z-[m-p]].

Si consideri l'espressione di sottrazione di classi di caratteri annidata [a-z-[d-w-[m-o]]]. L'espressione viene valutata partendo dall'intervallo di caratteri più interno verso quello più esterno. Innanzitutto, l'intervallo di caratteri compresi tra "m" e "o" viene sottratto dall'intervallo di caratteri compresi tra "d" e "w", producendo il set di caratteri compresi tra "d" e "l" e tra "p" e "w". Tale set viene quindi sottratto dall'intervallo di caratteri compreso tra "a" e "z", producendo il set di caratteri [abcmnoxyz].

È possibile utilizzare qualsiasi classe di caratteri con sottrazione di classi di caratteri. Per definire il set di caratteri che è costituito da tutti i caratteri Unicode compresi tra \u0000 e \uFFFF eccetto i caratteri di spazio (\s), i caratteri nella categoria generale punteggiatura (\p{P}), i caratteri nel blocco denominato IsGreek (\p{IsGreek}) e il carattere di controllo NEXT LINE Unicode (\x85), utilizzare [\u0000-\uFFFF-[\s\p{P}\p{IsGreek}\x85]].

Scegliere le classi di caratteri per un'espressione di sottrazione di classi di caratteri che produrrà risultati utili. Evitare espressioni che producono set di caratteri vuoti, che non hanno corrispondenze o che equivalgono al gruppo di base originale. Ad esempio, il set vuoto è il risultato dell'espressione [\p{IsBasicLatin}-[\x00-\x7F]], che sottrae tutti i caratteri compresi nell'intervallo di caratteri IsBasicLatin dalla categoria generale IsBasicLatin. Analogamente, il gruppo di base originale è il risultato dell'espressione [a-z-[0-9]]. Questo è dovuto al fatto che il gruppo di base, ovvero l'intervallo dei caratteri compresi tra le lettere 'a' e 'z', non contiene alcun carattere del gruppo escluso, ovvero dell'intervallo dei caratteri compresi tra le cifre decimali '0' e '9'.

Nell'esempio seguente viene definita un'espressione regolare, ^[0-9-[2468]]+$, che corrispondenze a zero e a cifre dispari in una stringa di input. L'espressione regolare viene interpretata come illustrato nella tabella seguente.

Elemento

Oggetto di descrizione

^

Iniziare la corrispondenza all'inizio della stringa di input.

[0-9-[2468]]+

Corrisponde a una o più occorrenze di qualsiasi carattere da 0 a 9 ad eccezione di 2, 4, 6 e 8. In altre parole, corrisponde a uno o più occorrenze di zero o di una cifra dispari.

$

Finisce la corrispondenza alla fine della stringa di input.

 
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim inputs() As String = { "123", "13579753", "3557798", "335599901" }
      Dim pattern As String = "^[0-9-[2468]]+$"

      For Each input As String In inputs
         Dim match As Match = Regex.Match(input, pattern)
         If match.Success Then Console.WriteLine(match.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       13579753
'       335599901

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "123", "13579753", "3557798", "335599901" };
      string pattern = @"^[0-9-[2468]]+$";

      foreach (string input in inputs)
      {
         Match match = Regex.Match(input, pattern);
         if (match.Success) 
            Console.WriteLine(match.Value);
      }      
   }
}
// The example displays the following output:
//       13579753
//       335599901

Torna all'inizio

Vedere anche

Riferimenti

GetUnicodeCategory

Opzioni di espressioni regolari

Concetti

Elementi del linguaggio di espressioni regolari