Linguaggio di espressioni regolari - Riferimento rapido

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:

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 altre 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 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"
\xNn 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"
\cX

\cX
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)
\unnnn 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 Corrispondenze
[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 carattere singolo che non si trova 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"
[Prima-Ultima] Intervallo di caratteri: corrisponde a qualsiasi carattere singolo nell'intervallo compreso tra primo e ultimo. [A-Z] "A", "B" in "AB123"
. Carattere jolly: corrisponde a qualsiasi carattere singolo, ad eccezione \ndi .

Per trovare la 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 di qualsiasi carattere singolo nella categoria generale Unicode o nel blocco denominato specificato in base al 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 alfanumerico. \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 diverso da spazi vuoti. \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.

Assertion Descrizione Modello Corrispondenze
^ 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 al punto in cui la corrispondenza precedente è terminata o se non è stata eseguita 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 Corrispondenze
(Sottoespressione) Acquisisce la sottoespressione corrispondente e le assegna un numero ordinale in base uno. (\w)\1 "ee" in "deep"
(?<Nome>Sottoespressione)
oppure
(?'Nome'Sottoespressione)
Acquisisce la sottoespressione corrispondente in un gruppo denominato. (?<double>\w)\k<double> "ee" in "deep"
(?<name1-name2>Sottoespressione)
oppure
(?'name1-name2'Sottoespressione)
Definisce una definizione di gruppo di bilanciamento. Per altre informazioni, vedere la sezione "Definizioni di 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()"

"Write" in "Console.Write(value)"
(?imnsx-imnsx:Sottoespressione) Applica o disabilita le opzioni specificate in sottoespressione. Per altre 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. \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" Pollici"ac"

niente in"abc"

Lookarounds a colpo d'occhio

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

Lookaround Nome Funzione
(?=check) Lookahead positivo Afferma che ciò che segue immediatamente la posizione corrente nella stringa è "check"
(?<=check) Lookbehind positivo Afferma che ciò che precede immediatamente la posizione corrente nella stringa è "check"
(?!check) Lookahead negativo Afferma che ciò che segue immediatamente la posizione corrente nella stringa non è "check"
(?<!check) Lookbehind negativo Afferma 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 quantifier 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 Corrispondenze
* 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 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"

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 altre 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)|No)
oppure
(?(Espressione))
Corrisponde a se il criterio di espressione regolare definito da espressione corrisponde. In caso contrario, corrisponde alla parte no facoltativa. espressione è 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) )|No)
(?(A)A\d{2}\b|\b\d{3}\b) "A10", "910" in "A10 C103 910"
(?(Nome)|No)
oppure
(?(Nome))
Corrisponde a yes se esiste una corrispondenza per name, un gruppo di acquisizione denominato o numerato. In caso contrario, corrisponde alla parte no facoltativa. (?<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 queste 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 lasottoespressione)del costrutto(?imnsx-imnsx: di raggruppamento, che definisce le opzioni solo per il gruppo specificato.

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

Opzione Descrizione Modello Corrispondenze
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 Miscellaneous Constructs.

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