Elementi del linguaggio di espressioni regolari
Un'espressione regolare è un modello per il quale il motore delle espressioni regolari tenta di trovare una corrispondenza nel testo di input. Un modello è costituito da uno o più i valori letterali carattere, operatori o costrutti. Per una breve introduzione, vedere Espressioni regolari di .NET Framework.
In ogni sezione di questa guida di riferimento rapido viene elencata una categoria specifica di caratteri, operatori e costrutti che è possibile utilizzare per definire le espressioni regolari:
Caratteri di escape
Classi di caratteri
Punti di ancoraggio
Costrutti di raggruppamento
Quantificatori
Costrutti di backreference
Costrutti di alternanza
Sostituzioni
Costrutti vari
Caratteri di escape
Il carattere barra rovesciata (\) in un'espressione regolare indica che il carattere successivo è un carattere speciale (come illustrato nella tabella seguente) oppure deve essere interpretato letteralmente. Per ulteriori informazioni, vedere Caratteri di escape.
Caratteri di escape |
Descrizione |
Modello |
Corrispondenze |
|---|---|---|---|
\a |
Trova la corrispondenza di un carattere di controllo del segnale acustico di avviso, \u0007. |
\a |
"\u0007" in "Error!" + '\u0007' |
\b |
In una classe di caratteri, trova la corrispondenza di un carattere backspace, \u0008. |
[\b]{3,} |
"\b\b\b\b" in "\b\b\b\b" |
\t |
Trova la corrispondenza di un carattere di tabulazione, \u0009. |
(\w+)\t |
"item1\t", "item2\t" in "item1\titem2\t" |
\r |
Trova la corrispondenza di un carattere di ritorno a capo, \u000D. \r non equivale al carattere di nuova riga \n. |
\r\n(\w+) |
"\r\nThese" in "\r\nThese are\ntwo lines." |
\v |
Trova la corrispondenza di un carattere di tabulazione verticale, \u000B. |
[\v]{2,} |
"\v\v\v" in "\v\v\v" |
\f |
Trova la corrispondenza di un carattere di avanzamento carta, \u000C. |
[\f]{2,} |
"\f\f\f" in "\f\f\f" |
\n |
Trova la corrispondenza di una nuova riga, \u000A. |
\r\n(\w+) |
"\r\nThese" in "\r\nThese are\ntwo lines." |
\e |
Trova la corrispondenza di un carattere di escape, \u001B. |
\e |
"\x001B" in "\x001B" |
\nnn |
Utilizza la rappresentazione ottale per specificare un carattere (nnn è costituito da un massimo di tre cifre). |
\w\040\w |
"a b", "c d" in "a bc d" |
\xnn |
Utilizza la rappresentazione esadecimale per specificare un carattere (nn è costituito da esattamente due cifre). |
\w\x20\w |
"a b", "c d" in "a bc d" |
\cX \cx |
Trova la corrispondenza del carattere di controllo ASCII specificato da X o x, dove X o x è la lettera del carattere di controllo. |
\cC |
"\x0003" in "\x0003" (Ctrl-C) |
\unnnn |
Trova la corrispondenza di un carattere Unicode utilizzando una rappresentazione esadecimale (esattamente quattro cifre, come rappresentate da nnnn). |
\w\u0020\w |
"a b", "c d" in "a bc d" |
\ |
Quando è seguito da un carattere non riconosciuto come carattere di escape, in questa e in altre tabelle del presente argomento, trova la corrispondenza di tale carattere. \* equivale, ad esempio, a \x2A. Questo consente al motore delle espressioni regolari di distinguere tra elementi del linguaggio, ad esempio * o ?, e valori letterali carattere, rappresentati da \* o \?. |
\d+[\+-x\*]\d+\d+[\+-x\*\d+ |
"2+2" e "3*9" in "(2+2) * 3*9" |
Torna all'inizio
Classi di caratteri
Una classe di caratteri trova la corrispondenza con uno qualsiasi di un set di caratteri. Le classi di caratteri includono gli elementi del linguaggio elencati nella tabella seguente. Per ulteriori informazioni, vedere Classi di caratteri.
Classe di caratteri |
Descrizione |
Modello |
Corrispondenze |
|---|---|---|---|
[gruppo_caratteri] |
Trova la corrispondenza di qualsiasi singolo carattere in gruppo_caratteri. Per impostazione predefinita, viene effettuata la distinzione tra maiuscole e minuscole. |
[ae] |
"a" in "gray" "a", "e" in "lane" |
[^gruppo_caratteri] |
Negazione: trova la corrispondenza di qualsiasi singolo carattere non incluso in gruppo_caratteri. Per impostazione predefinita, per i caratteri in gruppo_caratteri viene fatta distinzione tra maiuscole e minuscole. |
[^aei] |
"r", "g", "n" in "reign" |
[primo-ultimo] |
Intervallo di caratteri: trova la corrispondenza di qualsiasi carattere singolo nell'intervallo da primo a ultimo. |
[A-Z] |
"A", "B" in "AB123" |
. |
Carattere jolly: trova la corrispondenza di qualsiasi carattere singolo ad eccezione di "\n". |
a.e |
"ave" in "nave" "ate" in "water" |
\p{nome} |
Trova la corrispondenza di qualsiasi carattere singolo incluso nel blocco denominato o nella categoria generale Unicode specificato in nome. |
\p{Lu} \p{IsCyrillic} |
"C", "L" in "City Lights" "Д", "Ж" in "ДЖem" |
\P{nome} |
Trova la corrispondenza di qualsiasi carattere singolo non incluso nel blocco denominato o nella categoria generale Unicode specificato in nome. |
\P{Lu} \P{IsCyrillic} |
"i", "t", "y" in "City" "e", "m" in "ДЖem" |
\w |
Trova la corrispondenza di qualsiasi carattere alfabetico. |
\w |
"I", "D", "A", "1", "3" in "ID A1.3" |
\W |
Trova la corrispondenza di qualsiasi carattere non alfabetico. |
\W |
" ", "." in "ID A1.3" |
\s |
Trova la corrispondenza di qualsiasi carattere di spazio. |
\w\s |
"D " in "ID A1.3" |
\S |
Trova la corrispondenza di qualsiasi carattere diverso da uno spazio. |
\s\S |
" _" in "int __ctr" |
\d |
Trova la corrispondenza di qualsiasi cifra decimale. |
\d |
"4" in "4 = IV" |
\D |
Trova la corrispondenza di qualsiasi carattere che non sia una cifra decimale. |
\D |
" ", "=", " ", "I", "V" in "4 = IV" |
Torna all'inizio
Punti di ancoraggio
Gli ancoraggi, o asserzioni atomiche di larghezza zero, determinano l'esito della ricerca di una corrispondenza in base alla posizione corrente nella stringa, ma non comportano l'avanzamento del motore nella stringa o l'utilizzo di caratteri. I metacaratteri elencati nella tabella seguente sono ancoraggi. Per ulteriori informazioni, vedere Ancoraggi in espressioni regolari.
Asserzione |
Descrizione |
Modello |
Corrispondenze |
|---|---|---|---|
^ |
La corrispondenza deve iniziare all'inizio della stringa o della riga. |
^\d{3} |
"901-" in "901-333-" |
$ |
La corrispondenza deve verificarsi alla fine della stringa o prima di \n alla fine della riga o della stringa. |
-\d{3}$ |
"-333" in "-901-333" |
\A |
La corrispondenza deve verificarsi all'inizio della stringa. |
\A\d{3} |
"901" in "901-333-" |
\Z |
La corrispondenza deve verificarsi alla fine della stringa o prima di \n alla fine della stringa. |
-\d{3}\Z |
"-333" in "-901-333" |
\z |
La corrispondenza deve verificarsi alla fine della stringa. |
-\d{3}\z |
"-333" in "-901-333" |
\G |
La corrispondenza deve verificarsi nel punto in cui è terminata la corrispondenza precedente. |
\G\(\d\) |
"(1)", "(3)", "(5)" in "(1)(3)(5)[7](9)" |
\b |
La corrispondenza deve verificarsi sul limite tra un carattere \w (alfanumerico) e un carattere \W (non alfanumerico). |
\b\w+\s\w+\b |
"them them" in "them theme them them" |
\B |
La corrispondenza non deve verificarsi su un limite \b. |
\Bend\w*\b |
"ends", "ender" in "end sends endure lender" |
Torna all'inizio
Costrutti di raggruppamento
I costrutti di raggruppamento delineano sottoespressioni di un'espressione regolare e in genere acquisiscono sottostringhe di una stringa di input. I costrutti di raggruppamento includono gli elementi del linguaggio elencati nella tabella seguente. Per ulteriori informazioni, vedere Costrutti di raggruppamento.
Costrutto di raggruppamento |
Descrizione |
Modello |
Corrispondenze |
|---|---|---|---|
(sottoespressione) |
Acquisisce la sottoespressione corrispondente e le assegna un numero ordinale a base zero. |
(\w)\1 |
"ee" in "deep" |
(?<nome> sottoespressione) |
Acquisisce la sottoespressione corrispondente in un gruppo denominato. |
(?<double>\w)\k<double> |
"ee" in "deep" |
(?<nome1-nome2> sottoespressione) |
Definisce una definizione di gruppo di bilanciamento Per ulteriori informazioni, vedere la sezione "Definizione del gruppo di bilanciamento" in Costrutti di raggruppamento. |
(((?'Open'\()[^\(\)]*)+((?'Close-Open'\))[^\(\)]*)+)*(?(Open)(?!))$ |
"((1-3)*(3-1))" in "3+2^((1-3)*(3-1))" |
(?: sottoespressione) |
Definisce un gruppo di non acquisizione. |
Write(?:Line)? |
"WriteLine" in "Console.WriteLine()" |
(?imnsx-imnsx: sottoespressione) |
Applica o disabilita le opzioni specificate in sottoespressione. Per ulteriori informazioni, vedere Opzioni di espressioni regolari. |
A\d{2}(?i:\w+)\b |
"A12xl", "A12XL" in "A12xl A12XL a12xl" |
(?= sottoespressione) |
Asserzione lookahead positiva di larghezza zero. |
\w+(?=\.) |
"is", "ran" e "out" in "He is. The dog ran. The sun is out." |
(?! sottoespressione) |
Asserzione lookahead negativa di larghezza zero. |
\b(?!un)\w+\b |
"sure", "used" in "unsure sure unity used" |
(?<= sottoespressione) |
Asserzione lookbehind positiva di larghezza zero. |
(?<=19)\d{2}\b |
"99", "50", "05" in "1851 1999 1950 1905 2003" |
(?<! sottoespressione) |
Asserzione lookbehind negativa di larghezza zero. |
(?<!19)\d{2}\b |
"51", "03" in "1851 1999 1950 1905 2003" |
(?> sottoespressione) |
Sottoespressione non di backtracking (o "greedy"). |
[13579](?>A+B+) |
"1ABB", "3ABB" e "5AB" in "1ABB 3ABBC 5AB 5AC" |
Torna all'inizio
Quantificatori
Un quantificatore specifica il numero di istanze dell'elemento precedente, che può essere un carattere, un gruppo o una classe di caratteri, che devono essere presenti nella stringa di input affinché venga trovata una corrispondenza. I quantificatori includono gli elementi del linguaggio elencati nella tabella seguente. Per ulteriori informazioni, vedere Quantificatori.
Quantificatore |
Descrizione |
Modello |
Corrispondenze |
|---|---|---|---|
* |
Trova la corrispondenza dell'elemento precedente zero o più volte. |
\d*\. \d |
".0", "19.9", "219.9" |
+ |
Trova la corrispondenza dell'elemento precedente una o più volte. |
"be+" |
"bee" in "been", "be" in "bent" |
? |
Trova la corrispondenza dell'elemento precedente zero volte o una volta. |
"rai? n" |
"ran", "rain" |
{n} |
Trova la corrispondenza dell'elemento precedente esattamente n volte. |
",\d{3}" |
",043" in "1,043.6", ",876", ",543" e ",210" in "9,876,543,210" |
{n,} |
Trova la corrispondenza dell'elemento precedente almeno n volte. |
"\d{2,}" |
"166", "29", "1930" |
{n,m} |
Trova la corrispondenza dell'elemento precedente almeno n volte, ma non più di m volte. |
"\d{3,5}" |
"166", "17668" "19302" in "193024" |
*? |
Trova la corrispondenza dell'elemento precedente zero o più volte, ma il minor numero di volte possibile. |
\d*? \. \d |
".0", "19.9", "219.9" |
+? |
Trova la corrispondenza dell'elemento precedente una o più volte, ma il minor numero di volte possibile. |
"be+?" |
"be" in "been", "be" in "bent" |
?? |
Trova la corrispondenza dell'elemento precedente zero volte o una volta, ma il minor numero di volte possibile. |
"rai?? n" |
"ran", "rain" |
{n}? |
Trova la corrispondenza dell'elemento precedente esattamente n volte. |
",\d{3}?" |
",043" in "1,043.6", ",876", ",543" e ",210" in "9,876,543,210" |
{n,}? |
Trova la corrispondenza dell'elemento precedente almeno n volte, ma il minor numero di volte possibile. |
"\d{2,}?" |
"166", "29", "1930" |
{n,m}? |
Trova la corrispondenza dell'elemento precedente tra n e m volte, ma il minor numero di volte possibile. |
"\d{3,5}?" |
"166", "17668" "193", "024" in "193024" |
Torna all'inizio
Costrutti di backreference
Un backreference consente a una sottoespressione di cui è stata trovata la corrispondenza in precedenza di essere identificata successivamente nella stessa espressione regolare. Nella tabella seguente sono elencati i costrutti di backreference supportati dalle espressioni regolari in .NET Framework. Per ulteriori informazioni, vedere Costrutti di backreference.
Costrutto di backreference |
Descrizione |
Modello |
Corrispondenze |
|---|---|---|---|
\numero |
Backreference. Trova la corrispondenza del valore di una sottoespressione numerata. |
(\w)\1 |
"ee" in "seek" |
\k<nome> |
Backreference denominato. Trova la corrispondenza del valore di un'espressione denominata. |
(?<char>\w)\k<char> |
"ee" in "seek" |
Torna all'inizio
Costrutti di alternanza
I costrutti di alternanza modificano un'espressione regolare per abilitare la corrispondenza di tipo either/or. Questi costrutti includono gli elementi del linguaggio elencati nella tabella seguente. Per ulteriori informazioni, vedere Costrutti di alternanza.
Costrutto di alternanza |
Descrizione |
Modello |
Corrispondenze |
|---|---|---|---|
| |
Trova la corrispondenza di qualsiasi un elemento separato dal carattere di barra verticale. |
th(e|is|at) |
"the", "this" in "this is the day. " |
(?(espressione)sì|no) |
Trova la corrispondenza di sì se espressione corrisponde; in caso contrario, trova la corrispondenza della parte facoltativa no. espressione viene interpretata come asserzione di larghezza zero. |
(?(A)A\d{2}\b|\b\d{3}\b) |
"A10", "910" in "A10 C103 910" |
(?(nome)sì|no) |
Trova la corrispondenza di sì se viene trovata una corrispondenza per l'acquisizione denominata nome; in caso contrario, trova la corrispondenza della parte facoltativa no. |
(?<quoted>")?(?(quoted).+?"|\S+\s) |
Dogs.jpg, "Yiska playing.jpg" in "Dogs.jpg "Yiska playing.jpg"" |
Torna all'inizio
Sostituzioni
Le sostituzioni sono elementi del linguaggio di espressioni regolari supportati nei modelli di sostituzione. Per ulteriori informazioni, vedere Sostituzioni. I metacaratteri elencati nella tabella seguente sono asserzioni atomiche di larghezza zero.
Carattere |
Descrizione |
Modello |
Modello di sostituzione |
Stringa di input |
Stringa di risultato |
|---|---|---|---|---|---|
$numero |
Sostituisce la sottostringa corrispondente al gruppo numero. |
\b(\w+)(\s)(\w+)\b |
$3$2$1 |
"one two" |
"two one" |
${nome} |
Sostituisce la sottostringa corrispondente al gruppo denominato nome. |
\b(?<word1>\w+)(\s)(?<word2>\w+)\b |
${word2} ${word1} |
"one two" |
"two one" |
$$ |
Sostituisce un valore letterale "$". |
\b(\d+)\s?USD |
$$$1 |
"103 USD" |
"$103" |
$& |
Sostituisce una copia dell'intera corrispondenza. |
(\$*(\d*(\.+\d+)?){1}) |
**$& |
"$1.30" |
"**$1.30**" |
$` |
Sostituisce tutto il testo della stringa di input prima della corrispondenza. |
B+ |
$` |
"AABBCC" |
"AAAACC" |
$' |
Sostituisce tutto il testo della stringa di input successiva alla corrispondenza. |
B+ |
$' |
"AABBCC" |
"AACCCC" |
$+ |
Sostituisce l'ultimo gruppo acquisito. |
B+(C+) |
$+ |
"AABBCCDD" |
AACCDD |
$_ |
Sostituisce l'intera stringa di input. |
B+ |
$_ |
"AABBCC" |
"AAAABBCCCC" |
Torna all'inizio
Costrutti vari
I costrutti vari consentono di modificare un modello di espressione regolare o forniscono informazioni su di esso. Nella tabella seguente sono elencati i costrutti vari supportati da .NET Framework. Per ulteriori informazioni, vedere Costrutti vari.
Costrutto |
Definizione |
Esempio |
|---|---|---|
(?imnsx-imnsx) |
Imposta o disabilita opzioni come la distinzione tra maiuscole e minuscole nella parte centrale di un modello. Per ulteriori informazioni, vedere Opzioni di espressioni regolari. |
\bA(?i)b\w+\b trova la corrispondenza di "ABA", "Able" in "ABA Able Act" |
(?# commento ) |
Commento inline. Il commento termina in corrispondenza della prima parentesi chiusa. |
\bA(?#Matches words starting with A)\w+\b |
# [fino alla fine della riga] |
Commento in modalità X. Il commento inizia da un carattere # senza codice di escape e continua fino alla fine della riga. |
(?x)\bA\w+\b#Matches words starting with A |
Torna all'inizio
Vedere anche
Riferimenti
System.Text.RegularExpressions
Concetti
Espressioni regolari di .NET Framework
Classi di espressioni regolari
Altre risorse
Procedure consigliate per le espressioni regolari in .NET Framework