Condividi tramite

Linguaggio di espressioni regolari - Riferimento rapido

  • Articolo

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.

In ogni sezione di questa guida di riferimento rapido viene elencata una categoria specifica di caratteri, operatori e costrutti che è possibile usare per definire espressioni regolari.

Queste informazioni sono state fornite anche in due formati che è possibile scaricare e stampare per un riferimento semplice:

Escape di caratteri

Il carattere barra rovesciata (\) in un'espressione regolare indica che il carattere che segue è un carattere speciale (come illustrato nella tabella seguente) o deve essere interpretato letteralmente. Per altre informazioni, vedere Caratteri di escape.

Caratteri di escape Descrizione Modello Matches
\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 Usa 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"
\x nn Usa la rappresentazione esadecimale per specificare un carattere (nn è costituito da esattamente due cifre). \w\x20\w "a b", "c d" in "a bc d"
\c X

\c x		 Trova la corrispondenza con il 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)
\u nnnn Trova la corrispondenza di un carattere Unicode usando 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. Ad esempio, \* corrisponde a \x2Ae \. corrisponde a \x2E. Questo permette al motore delle espressioni regolari di distinguere tra elementi del linguaggio, ad esempio * o ? e valori letterali carattere, rappresentati da \* o \?. \d+[\+-x\*]\d+ "2+2" e "3*9" in "(2+2) * 3*9"

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 altre informazioni, vedere Classi di caratteri.

Classe di caratteri Descrizione Modello Matches
[ character_group ] Trova la corrispondenza con qualsiasi carattere singolo in character_group. Per impostazione predefinita, viene effettuata la distinzione tra maiuscole e minuscole. [ae] "a" in "gray"

"a", "e" in "lane"
[^ character_group ] Negazione: corrisponde a qualsiasi singolo carattere non incluso in character_group. Per impostazione predefinita, per i caratteri in character_group si fa distinzione tra maiuscole e minuscole. [^aei] "r", "g", "n" in "reign"
[primo - ultimo ] Intervallo di caratteri: corrisponde a qualsiasi carattere singolo nell'intervallo compreso tra il primo e l'ultimo. [A-Z] "A", "B" in "AB123"
. Carattere jolly: corrisponde a qualsiasi carattere singolo, ad eccezione di \n.

Per trovare una corrispondenza con un carattere punto letterale (. o \u002E), è necessario precederlo con il carattere di escape (\.).		 a.e "ave" in "nave"

"ate" in "water"
\p{ nome } Trova la corrispondenza con qualsiasi carattere singolo nella categoria generale Unicode o nel blocco denominato specificato per nome. \p{Lu}

\p{IsCyrillic}		 "C", "L" in "City Lights"

"Д", "Ж" in "ДЖem"
\P{ nome } Trova la corrispondenza con qualsiasi carattere singolo che non si trova nella categoria generale Unicode o nel blocco denominato specificato per nome. \P{Lu}

\P{IsCyrillic}		 "i", "t", "y" in "City"

"e", "m" in "ДЖem"
\w Trova la corrispondenza con qualsiasi carattere di parola. \w "I", "D", "A", "1", "3" in "ID A1.3"
\W Trova la corrispondenza con qualsiasi carattere non parola. \W " ", "." in "ID A1.3"
\s Trova la corrispondenza con qualsiasi carattere di spazio vuoto. \w\s "D " in "ID A1.3"
\S Trova la corrispondenza con qualsiasi carattere non vuoto. \s\S " _" in "int __ctr"
\d Trova la corrispondenza con qualsiasi cifra decimale. \d "4" in "4 = IV"
\D Trova la corrispondenza con qualsiasi carattere diverso da una cifra decimale. \D " ", "=", " ", "I", "V" in "4 = IV"

Ancoraggi

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 altre informazioni, vedere Ancoraggi.

Asserzione Descrizione Modello Matches
^ Per impostazione predefinita, la corrispondenza deve iniziare all'inizio della stringa; in modalità multiriga, deve iniziare all'inizio della riga. ^\d{3} "901" in "901-333-"
$ Per impostazione predefinita, la corrispondenza deve verificarsi alla fine della stringa oppure prima di \n alla fine della stringa; in modalità multiriga, deve verificarsi prima della fine della riga oppure prima di \n alla fine della riga. -\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 o se non è stata trovata alcuna corrispondenza precedente, nella posizione nella stringa in cui è stata avviata la corrispondenza. \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 theme", "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"

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 altre informazioni, vedere Costrutti di raggruppamento.

Costrutto di raggruppamento Descrizione Modello Matches
( sottoespressione ) Acquisisce la sottoespressione corrispondente e le assegna un numero ordinale in base uno. (\w)\1 "ee" in "deep"
(?<nome > sottoespressione )
o
(?'nome ' sottoespressione )		 Acquisisce la sottoespressione corrispondente in un gruppo denominato. (?<double>\w)\k<double> "ee" in "deep"
(?<name1 - name2 > sottoespressione )
o
(?'name1 - name2 ' sottoespressione )		 Definisce una definizione di gruppo di bilanciamento Per altre informazioni, vedere la sezione "Definizioni di gruppo di bilanciamento" in Grouping Constructs. (((?'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()"

"Write" in "Console.Write(value)"
(?imnsx-imnsx: sottoespressione ) Applica o disabilita le opzioni specificate in sottoespressione. Per altre informazioni, vedere Regular Expression Options. A\d{2}(?i:\w+)\b "A12xl", "A12XL" in "A12xl A12XL a12xl"
(?= sottoespressione ) Asserzione lookahead positiva di larghezza zero. \b\w+\b(?=.+and.+) "cats", "dogs"
in
"cats, dogs and some mice."
(?! sottoespressione ) Asserzione lookahead negativa di larghezza zero. \b\w+\b(?!.+and.+) "and", "some", "mice"
in
"cats, dogs and some mice."
(?<= sottoespressione ) Asserzione lookbehind positiva di larghezza zero. \b\w+\b(?<=.+and.+)

———————————

\b\w+\b(?<=.+and.*)		 "some", "mice"
in
"cats, dogs and some mice."
————————————
"and", "some", "mice"
in
"cats, dogs and some mice."
(?<! sottoespressione ) Asserzione lookbehind negativa di larghezza zero. \b\w+\b(?<!.+and.+)

———————————

\b\w+\b(?<!.+and.*)		 "cats", "dogs", "and"
in
"cats, dogs and some mice."
————————————
"cats", "dogs"
in
"cats, dogs and some mice."
(?> sottoespressione ) Gruppo atomico. '(?>a|ab)c "ac" in"ac"

niente in"abc"

Lookarounds a colpo d'occhio

Quando il motore delle espressioni regolari raggiunge un'espressione lookaround, accetta una sottostringa che raggiunge la posizione corrente fino all'inizio (lookbehind) o alla fine (lookahead) della stringa originale e quindi viene eseguita Regex.IsMatch su tale sottostringa usando il modello lookaround. Il risultato di questa sottoespressione viene quindi determinato dal fatto che si tratti di un'asserzione positiva o negativa.

Lookaround Nome Funzione
(?=check) Lookahead positivo Asserisce che ciò che segue immediatamente la posizione corrente nella stringa è "check"
(?<=check) Lookbehind positivo Asserisce che ciò che precede immediatamente la posizione corrente nella stringa è "check"
(?!check) Lookahead negativo Asserisce che ciò che segue immediatamente la posizione corrente nella stringa non è "check"
(?<!check) Lookbehind negativo Asserisce che ciò che precede immediatamente la posizione corrente nella stringa non è "check"

Dopo aver eseguito la corrispondenza, i gruppi atomici non verranno rivalutati, anche quando il resto del modello non riesce a causa della corrispondenza. Ciò può migliorare significativamente le prestazioni quando i quantificatori si verificano all'interno del gruppo atomico o il resto del modello.

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 altre informazioni, vedere Quantificatori .

Quantificatore Descrizione Modello Matches
* Trova la corrispondenza dell'elemento precedente zero o più volte. a.*c "abcbc" in "abcbc"
+ Trova la corrispondenza dell'elemento precedente una o più volte. "be+" "bee" in "been", "be" in "bent"
? Trova la corrispondenza con l'elemento precedente zero volte o una volta soltanto. "rai?" "rai" in "rain"
{n} Trova la corrispondenza con l'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 con l'elemento precedente almeno n volte. "\d{2,}" "166", "29", "1930"
{ n , m } Trova la corrispondenza con l'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. a.*?c "abc" in "abcbc"
+? 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??" "ra" in "rain"
{n}? Trova la corrispondenza con l'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 con l'elemento precedente tra n e m volte, ma il minor numero di volte possibile. "\d{3,5}?" "166", "17668"

"193", "024" in "193024"

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. Per altre informazioni, vedere Backreference Constructs.

Costrutto di backreference Descrizione Modello Matches
\ 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"

Alternation Constructs

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 altre informazioni, vedere Costrutti di alternanza.

Costrutto di alternanza Descrizione Modello Matches
| 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 )
o
(?( espressione ) sì )		 Corrisponde a sì se il criterio di espressione regolare definito da espressione corrisponde. In caso contrario, corrisponde alla parte no facoltativa. expression è interpretata come asserzione di larghezza zero.

Per evitare ambiguità con un gruppo di acquisizione denominato o numerato, è possibile usare facoltativamente un'asserzione esplicita, come illustrato di seguito:
(?( (?= espressione ) ) sì | no )		 (?(A)A\d{2}\b|\b\d{3}\b) "A10", "910" in "A10 C103 910"
(?( nome ) sì | no )
o
(?( nome ) sì )		 Corrisponde a yes se nome, un gruppo di acquisizione denominato o numerato, dispone di una corrispondenza.In caso contrario, corrisponde al nofacoltativo. (?<quoted>")?(?(quoted).+?"|\S+\s) "Dogs.jpg ", "\"Yiska playing.jpg\"" in "Dogs.jpg \"Yiska playing.jpg\""

Sostituzioni

Le sostituzioni sono elementi del linguaggio di espressioni regolari supportati nei modelli di sostituzione. Per altre 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 number. \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.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"

Opzioni di espressioni regolari

È possibile specificare opzioni che controllano il modo in cui il motore delle espressioni regolari interpreta un criterio di espressione regolare. Molte di queste opzioni possono essere specificate inline (nel criterio di espressione regolare) o come uno o più costanti RegexOptions. Questa guida di riferimento rapida elenca solo le opzioni inline. Per altre informazioni sulle opzioni inline e RegexOptions, vedere l'articolo Opzioni di espressioni regolari.

È possibile specificare un'opzione inline in due modi:

  • Usando il costrutto (?imnsx-imnsx)varie , dove un segno meno (-) prima di un'opzione o un set di opzioni disattiva tali opzioni. Ad esempio, (?i-mn) attiva la non corrispondenza tra maiuscole e minuscole (i), disattiva la modalità su più righe (m) e disattiva le acquisizioni del gruppo senza nome (n). L'opzione si applica al criterio di espressione regolare dal punto in cui l'opzione viene definita e diventa effettiva sia alla fine del criterio sia al punto in cui un altro costrutto annulla l'opzione.
  • Usando il costrutto di raggruppamento(?imnsx-imnsx:subexpressione), che definisce le opzioni solo per il gruppo specificato.

Il motore delle espressioni regolari .NET supporta le opzioni inline seguenti:

Opzione Descrizione Modello Matches
i Usa la corrispondenza che non fa distinzione tra maiuscole e minuscole. \b(?i)a(?-i)a\w+\b "aardvark", "aaaAuto" in "aardvark AAAuto aaaAuto Adam breakfast"
m Usare la modalità multiriga. ^ e $ corrispondono all'inizio e alla fine di una riga, anziché all'inizio e alla fine della stringa di input. Ad esempio, vedere la sezione "Modalità multiriga" in Opzioni di espressioni regolari.
n Non acquisire gruppi senza nome. Per un esempio, vedere la sezione "Solo acquisizioni esplicite" in Opzioni di espressioni regolari.
s Usare la modalità a riga singola. Per un esempio, vedere la sezione "Modalità a riga singola" in Opzioni di espressioni regolari.
x Ignorare gli spazi vuoti non di escape nel criterio di espressione regolare. \b(?x) \d+ \s \w+ "1 aardvark", "2 cats" in "1 aardvark 2 cats IV centurions"

Costrutti vari

I costrutti vari consentono di modificare un criterio di espressione regolare o forniscono informazioni su di esso. Nella tabella seguente sono elencati i costrutti vari supportati da .NET. Per altre 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 altre informazioni, vedere Opzioni di espressioni regolari. \bA(?i)b\w+\b corrisponde a "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

Vedi anche