Classi di caratteri
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.
Importante |
---|
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\.
Nota |
---|
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.
Nota |
---|
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.
Nota |
---|
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.
Nota |
---|
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
Opzioni di espressioni regolari