Tabella di consultazione della sintassi delle espressioni regolari

Le espressioni regolari, conosciute anche come espressioni di regole, sono un modello di testo utilizzato comunemente per cercare, sostituire e controllare il testo. Comprendono lettere da a a z e alcuni caratteri speciali. Le espressioni regolari hanno una vasta gamma di applicazioni, inizialmente diffuse da Unix e successivamente utilizzate in Scala, PHP, C#, Java, C++, Objective-C, Perl, Swift, VBScript, Javascript, Ruby e Python, tra gli altri. Studiare le espressioni regolari significa in realtà acquisire una forma di pensiero logico molto flessibile, imparando tecniche semplici e veloci per controllare le stringhe.

Carattere regex	Descrizione
\	Attacca il carattere successivo come un carattere speciale, o un carattere letterale, o un riferimento retrospettivo, o una sequenza di escape ottale. Ad esempio, "“`n`" corrisponde al carattere "`n`". "`\n`" corrisponde a una nuova riga. La stringa "`\\`" corrisponde a "`\`" e "`\(`" corrisponde a "`(`".
^	Corrisponde all'inizio della stringa di input. Se il parametro Multiline dell'oggetto RegExp è impostato, ^ corrisponde anche alla posizione dopo "“`\n`" o "`\r`".
$	Corrisponde alla fine della stringa di input. Se il parametro Multiline dell'oggetto RegExp è impostato, $ corrisponde anche alla posizione prima di "“`\n`" o "`\r`".
*	Corrisponde all'espressione secondaria precedente zero o più volte. Ad esempio, zo* può corrispondere a "“`z`" e "`zoo`". * è equivalente a {0,}.
+	Corrisponde all'espressione secondaria precedente una o più volte. Ad esempio, "“`zo+`" può corrispondere a "`zo`" e "`zoo`", ma non può corrispondere a "`z`". + è equivalente a {1,}.
?	Corrisponde all'espressione secondaria precedente zero o una volta. Ad esempio, "“`do(es)?`" può corrispondere a "`does`" o a "`do`" in "`does`". ? è equivalente a {0,1}.
{n}	n è un numero intero non negativo. Corrisponde a un certo numero di volte definiti n. Ad esempio, "“`o{2}`" non può corrispondere a "`Bob`" in "`o`", ma può corrispondere a due o in "`food`".
{n,}	n è un numero intero non negativo. Corrisponde a un numero di volte non inferiore a n. Ad esempio, "“`o{2,}`" non può corrispondere a "`Bob`" in "`o`", ma può corrispondere a tutti gli o in "`foooood`". "`o{1,}`" è equivalente a "`o+`". "`o{0,}`" è equivalente a "`o*`".
{n,m}	m e n sono numeri interi non negativi, dove n<=m. Corrisponde a un numero di volte almeno n e al massimo m. Ad esempio, "“`o{1,3}`" corrisponderà ai primi tre o in "`fooooood`". "`o{0,1}`" è equivalente a "`o?`". Si prega di notare che non possono esserci spazi tra la virgola e i due numeri.
?	Quando questo carattere segue qualsiasi altro quantificatore (*, +, ?, {n}, {n,}, {n,m}), la corrispondenza è non avido. La modalità non avid è quella in cui si cerca di abbinare il minor numero possibile di caratteri mentre la modalità avida cerca di abbinare il maggior numero possibile. Ad esempio, per la stringa "“`oooo`", "`o+?`" corrisponderà a un singolo "`o`", mentre "`o+`" corrisponderà a tutti gli "`o`".
.	Corrisponde a qualsiasi singolo carattere tranne "“`\n`". Per abbinare qualsiasi carattere, inclusa la "“`\n`", utilizzare un modello come "`(.\|\n)`".
(pattern)	Corrisponde al pattern e ottiene questa corrispondenza. La corrispondenza ottenuta può essere recuperata dalla raccolta di Matches generata e, in VBScript, dalla raccolta SubMatches; in JScript, dai attributi $0...$9. Per abbinare i caratteri di parentesi, utilizzare "“`$`" o "`$`".
(?:pattern)	Corrisponde al pattern ma non ottiene il risultato della corrispondenza, cioè è una corrispondenza non recuperata, non viene memorizzata per un uso successivo. Ciò è utile quando si utilizza il carattere di alternanza "“`(\|)`" per combinare diverse parti di un pattern. Ad esempio, "`industr(?:y\|ies)`" è un'espressione più concisa rispetto a "`industry\|industries`".
(?=pattern)	Controllo affermativo in avanti, corrisponde a qualsiasi stringa che inizia con una stringa che corrisponde al pattern. È una corrispondenza non recuperata, cioè questa corrispondenza non deve essere ottenuta per un uso successivo. Ad esempio, "“`Windows(?=95\|98\|NT\|2000)`" può abbinare "`Windows2000`" ma non può abbinare "`Windows3.1`". Il lookahead non consuma caratteri, cioè, dopo che si è verificata una corrispondenza, la ricerca della successiva abbinamento inizia immediatamente dopo l'ultima corrispondenza e non inizia dopo i caratteri contenenti il lookahead.
(?!pattern)	Controllo di negazione in avanti, corrisponde a qualsiasi stringa che non corrisponde al pattern. È una corrispondenza non recuperata, cioè questa corrispondenza non deve essere ottenuta per un uso successivo. Ad esempio "“`Windows(?!95\|98\|NT\|2000)`" può abbinare "`Windows3.1`" ma non può abbinare "`Windows2000`". Anche il lookbehind non consuma caratteri, cioè, dopo che si è verificata una corrispondenza, la ricerca della successiva corrispondenza inizia immediatamente dopo l'ultima corrispondenza e non inizia dopo i caratteri contenenti il lookbehind.
(?<=pattern)	Controllo affermativo all'indietro, simile al controllo affermativo in avanti ma con la direzione opposta. Ad esempio, "“`(?<=95\|98\|NT\|2000)Windows`" può abbinare "`2000Windows`", ma non può abbinare "`3.1Windows`".
(?<!pattern)	Controllo di negazione all'indietro, simile al controllo di negazione in avanti ma con la direzione opposta. Ad esempio "“`(?<!95\|98\|NT\|2000)Windows`" può abbinare "`3.1Windows`", ma non può abbinare "`2000Windows`".
x\|y	Corrisponde a x o y. Ad esempio, "“`z\|food`" può abbinare "`z`" o "`food`". "`(z\|f)ood`" corrisponde a "`zood`" o "`food`".
[xyz]	Collezione di caratteri. Corrisponde a qualsiasi carattere contenuto. Ad esempio, "“`[abc]`" può corrispondere a "`a`" in "`plain`".
[^xyz]	Collezione di caratteri negativa. Corrisponde a qualsiasi carattere non incluso. Ad esempio, "“`[^abc]`" può corrispondere a "`p`" in "`plain`".
[a-z]	Intervallo di caratteri. Corrisponde a qualsiasi carattere nel range specificato. Ad esempio, "“`[a-z]`" può corrispondere a qualsiasi lettera minuscola da "`a`" a "`z`".
[^a-z]	Intervallo di caratteri negativo. Corrisponde a qualsiasi carattere non nel range specificato. Ad esempio, "“`[^a-z]`" può corrispondere a qualsiasi carattere non compreso tra "`a`" e "`z`".
\b	Corrisponde a un confine di parola, cioè alla posizione tra una parola e uno spazio. Ad esempio, "“`er\b`" può corrispondere a "`never`" in "`er`", ma non può corrispondere a "`verb`" in "`er`".
\B	Corrisponde a un confine di parola non. "“`er\B`" può corrispondere a "`verb`" in "`er`", ma non può corrispondere a "`never`" in "`er`".
\cx	Corrisponde a un carattere di controllo specificato da x. Ad esempio, \cM corrisponde a un Control-M o a un carattere di ritorno. Il valore di x deve essere A-Z o a-z. Altrimenti, c è considerato un carattere letterale "“`c`".
\d	Corrisponde a un carattere numerico. È equivalente a [0-9].
\D	Corrisponde a un carattere non numerico. È equivalente a [^0-9].
\f	Corrisponde a un carattere di feed page. È equivalente a \x0c e \cL.
\n	Corrisponde a un carattere di nuova riga. È equivalente a \x0a e \cJ.
\r	Corrisponde a un carattere di ritorno. È equivalente a \x0d e \cM.
\s	Corrisponde a qualsiasi carattere bianco, inclusi spazi, tabulazioni, feed page, ecc. È equivalente a [ \f\n\r\t\v].
\S	Corrisponde a qualsiasi carattere non bianco. È equivalente a [^ \f\n\r\t\v].
\t	Corrisponde a un carattere di tabulazione. È equivalente a \x09 e \cI.
\v	Corrisponde a un carattere di tabulazione verticale. È equivalente a \x0b e \cK.
\w	Corrisponde a qualsiasi carattere di parola, inclusi i caratteri di sottolineatura. È equivalente a "“`[A-Za-z0-9_]`".
\W	Corrisponde a qualsiasi carattere non di parola. È equivalente a "“`[^A-Za-z0-9_]`".
\xn	Corrisponde a n, dove n è un valore di escape esadecimale. I valori di escape esadecimali devono essere di lunghezza esatta di due numeri. Ad esempio, "“`\x41`" corrisponde a "`A`". "`\x041`" è equivalente a "`\x04&1`". Puoi usare i codici ASCII nelle espressioni regolari.
\num	Corrisponde a num, dove num è un numero intero positivo. Serve a riferirsi alla corrispondenza ottenuta. Ad esempio, "“`(.)\1`" corrisponde a due caratteri uguali e consecutivi.
\n	Identifica un valore di escape ottale o un riferimento retrospettivo. Se c'è stata almeno n corrispondenza precedenti di espressioni secondarie, n è un riferimento retrospettivo. Altrimenti, se n è un numero ottale (0-7), allora n rappresenta un valore di escape ottale.
\nm	Identifica un valore di escape ottale o un riferimento retrospettivo. Se ci sono state almeno nm corrispondenze di espressioni secondarie, nm è un riferimento retrospettivo. Se ci sono state almeno n corrispondenze precedenti, n è un riferimento retrospettivo seguito dal carattere m. Se nessuna delle condizioni precedenti è soddisfatta e n e m sono entrambi numeri ottali (0-7), allora nm corrisponderà al valore di escape ottale nm.
\nml	Se n è un numero ottale (0-3) e sia m che l sono numeri ottali (0-7), allora corrisponderà al valore di escape ottale nml.
\un	Corrisponde a n, dove n è un carattere Unicode rappresentato da quattro cifre esadecimali. Ad esempio, \u00A9 corrisponde al simbolo di copyright (©).

Espressioni regolari comuni

Nome utente	/^[a-z0-9_-]{3,16}$/
Password	/^[a-z0-9_-]{6,18}$/
Password 2	(?=^.{8,}$)(?=.\d)(?=.\W+)(?=.[A-Z])(?=.[a-z])(?!.\n).$ (composto da numeri / lettere maiuscole / lettere minuscole / simboli, tutti e quattro devono essere presenti, più di 8 caratteri)
Valori esadecimali	/^#?([a-f0-9]{6}\|[a-f0-9]{3})$/
Email	/^([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$/ /^[a-z\d]+(\.[a-z\d]+)@([\da-z](-[\da-z])?)+(\.{1,2}[a-z]+)+$/ o \w+([-+.]\w+)@\w+([-.]\w+)\.\w+([-.]\w+)
URL	/^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-])\/?$/ o [a-zA-z]+://[^\s]*
Indirizzo IP	/((2[0-4]\d\|25[0-5]\|[01]?\d\d?)\.){3}(2[0-4]\d\|25[0-5]\|[01]?\d\d?)/ /^(?:(?:25[0-5]\|2[0-4][0-9]\|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]\|2[0-4][0-9]\|[01]?[0-9][0-9]?)$/ o ((2[0-4]\d\|25[0-5]\|[01]?\d\d?)\.){3}(2[0-4]\d\|25[0-5]\|[01]?\d\d?)
Tag HTML	/^<([a-z]+)([^<]+)(?:>(.)<\/\1>\|\s+\/>)$/ o <(.)(.)>.<\/\1>\|<(.) \/>
Rimuovi commenti\\codice	(?<!http:\|\S)//.*$
Abbinamento di caratteri a byte doppio (inclusi i caratteri cinesi)	[^\x00-\xff]
Caratteri cinesi (caratteri)	[\u4e00-\u9fa5]
Intervallo dei caratteri cinesi nella codifica Unicode	/^[\u2E80-\u9FFF]+$/
Caratteri e punteggiatura cinese a larghezza piena (caratteri)	[\u3000-\u301e\ufe10-\ufe19\ufe30-\ufe44\ufe50-\ufe6b\uff01-\uffee]
Data (anno-mese-giorno)	(\d{4}\|\d{2})-((0?([1-9]))\|(1[1\|2]))-((0?[1-9])\|([12]([1-9]))\|(3[0\|1]))
Data (mese/giorno/anno)	((0?[1-9]{1})\|(1[1\|2]))/(0?[1-9]\|([12][1-9])\|(3[0\|1]))/(\d{4}\|\d{2})
Ora (ore:minuti, formato 24 ore)	((1\|0?)[0-9]\|2[0-3]):([0-5][0-9])
Numero di telefono fisso della Cina continentale	(\d{4}-\|\d{3}-)?(\d{8}\|\d{7})
Numero di cellulare della Cina continentale	1\d{10}
Codice postale della Cina continentale	[1-9]\d{5}
Numero di identificazione della Cina continentale (15 o 18 cifre)	\d{15}(\d\d[0-9xX])?
Numeri interi non negativi (interi positivi o zero)	\d+
Numeri interi positivi	[0-9][1-9][0-9]
Numeri interi negativi	-[0-9][1-9][0-9]
Numeri interi	-?\d+
Numeri decimali	(-?\d+)(\.\d+)?
Linee vuote	\n\s\r o \n\n(editplus) o ^[\s\S ]\n
Numeri QQ	[1-9]\d{4,}
Parole che non contengono abc	\b((?!abc)\w)+\b
Corrispondenza di spazi bianchi all'inizio e alla fine	^\s\|\s$
Modifiche comuni	Ecco alcune sostituzioni per caratteri speciali in cinese (editplus) ^[0-9].\n ^[^第].\n ^[习题].\n ^[\s\S ]\n ^[0-9]\. ^[\s\S ]\n <p[^<>]> href="javascript:if$confirm\('(.?)'$\)window\.location='(.?)'" <span style=".[^"]rgb$255,255,255$">.[^<>]</span> <DIV class=xs0>[\s\S]?</DIV>

Tabella rapida della sintassi delle espressioni regolari - Tecniche e sintassi comuni delle espressioni regolari

Le espressioni regolari sono uno strumento potente per la gestione del testo. Questa pagina fornisce una tabella rapida della sintassi delle espressioni regolari per aiutarti a comprendere rapidamente la sintassi di base, i modificatori, le sottodichiarazioni, le modalità avida e non avida, ecc.

Sintassi di base delle espressioni regolari

Le espressioni regolari vengono utilizzate per descrivere le regole di un modello di stringa. Le sintassi di base comuni includono:

Punto (.) : Corrisponde a qualsiasi singolo carattere (esclusi i caratteri di nuova riga).
Set di caratteri ([ ]) : Corrisponde a qualsiasi carattere contenuto tra parentesi. Ad esempio: [a-z] corrisponde a tutte le lettere minuscole.
Esclusione del set di caratteri ([^ ]) : Corrisponde ai caratteri non contenuti tra parentesi. Ad esempio: [^0-9] corrisponde ai caratteri non numerici.
Quantificatori (*, +, ?) : Indicano il numero di corrispondenze. Ad esempio: a* indica che corrispondono zero o più a.
Ancora (^, $) : ^ indica l'inizio della stringa, $ indica la fine della stringa.

Modificatori comuni delle espressioni regolari

I modificatori delle espressioni regolari vengono utilizzati per cambiare le regole di corrispondenza delle espressioni regolari; i modificatori comuni includono:

g (corrispondenza globale) : Corrisponde a tutte le stringhe che soddisfano, non solo la prima.
i (ignora maiuscole e minuscole) : Ignora le maiuscole e minuscole per la corrispondenza.
m (corrispondenza multilinea) : Permette a ^ e $ di corrispondere all'inizio e alla fine di ogni riga.

Modalità avida e non avida

Negli espressioni regolari, i quantificatori sono per default avidi e cercano di abbinare il maggior numero di caratteri possibile. La modalità non avida si utilizza aggiungendo un ? dopo il quantificatore, come mostrato di seguito:

Modalità avida : a.*b corrisponde a tutti i caratteri tra a e b (inclusi più b).
Modalità non avida : a.*?b corrisponde al minor numero di caratteri tra a e b.

Sottodichiarazioni e gruppi

Le sottodichiarazioni nelle espressioni regolari vengono definite con parentesi (( )), e vengono comunemente utilizzate per estrarre parti corrispondenti. I gruppi si realizzano attraverso il simbolo “|”. Ad esempio:

Sottodichiarazione : (abc) corrisponde e cattura la stringa “abc”.
Gruppo : (abc|def) corrisponde a “abc” o “def”.

Consultazione rapida delle espressioni regolari

Di seguito è riportata una consultazione rapida delle espressioni regolari comuni:

Funzione	Espressione regolare
Corrisponde a numeri	\d
Corrisponde a caratteri non numerici	\D
Corrisponde a lettere	[a-zA-Z]
Corrisponde a qualsiasi carattere	.
Corrisponde a caratteri bianchi	\s

Applicazioni delle espressioni regolari

Le espressioni regolari sono ampiamente utilizzate nei seguenti scenari:

Validazione dei dati: ad esempio, convalida il formato di email, numero di telefono, indirizzo IP, ecc.
Ricerca del testo: trova le stringhe corrispondenti nel testo.
Pulizia dei dati: utilizza le espressioni regolari per eliminare o sostituire caratteri o modelli specifici.
Analisi dei log: estrai le informazioni dai file di log, filtrando le righe di log specifiche.

Consigli per apprendere le espressioni regolari

Inizia semplice: inizia a padroneggiare i simboli e le sintassi di base, quindi procedi a espressioni regolari più complesse.
Fai molte esercitazioni: applica le espressioni regolari per approfondire la comprensione.
Utilizza strumenti per espressioni regolari: utilizza strumenti per il test delle espressioni regolari per verificare e fare debugging delle espressioni regolari.

Utilizza immediatamente la nostra tabella rapida della sintassi delle espressioni regolari, per rendere la scrittura delle espressioni regolari più efficiente e migliorare le tue capacità di elaborazione del testo!