Usa espressioni regolari

Le espressioni regolari sono caratteri che vengono combinati secondo un modello specifico (sintassi) e che possono essere utilizzati per ricerche avanzate di tipo trova e/o sostituisci. L'implementazione delle espressioni regolari utilizza la sintassi del modello di espressione regolare ECMAScript.

Tip

Osservare la barra di stato per verificare se le espressioni regolari non sono valide o se la stringa di ricerca non produce corrispondenze. Utilizzare il menu espressioni regolari per creare modelli validi.

Attivare l'icona Usa espressioni regolari nella finestra di dialogo Trova

Caratteri speciali di modello

I caratteri speciali di modello sono caratteri (o sequenze di caratteri) che hanno un significato speciale quando appaiono in un'espressione regolare, sia per rappresentare un carattere difficile da esprimere in una stringa, sia per rappresentare una categoria di caratteri. Ciascuno di questi caratteri speciali di modello viene confrontato nella sequenza di destinazione con un singolo carattere (a meno che un quantificatore non specifichi diversamente).

Sintassi	Descrizione	Esempio
\w	Qualsiasi carattere alfanumerico o carattere di sottolineatura	`test\wnew` trova test2new o test_new
\W	Qualsiasi carattere che non sia un carattere alfanumerico o un carattere di sottolineatura	`test\Wnew` trova test.new o test-new
\d	Qualsiasi carattere numerico	`test\d\d` trova test21
\D	Qualsiasi carattere che non sia un carattere numerico	`test\D\D` trova test_a
\s	Qualsiasi carattere di spazio, carattere di tabulazione o carattere di fine della riga (CR)(LF)	`test\s1` trova test 1
\S	Qualsiasi carattere che non sia un carattere di spazio, un carattere di tabulazione o un carattere di fine della riga (CR)(LF)	`test\S1` trova test_1
\t	Tabulatore	`a\tb` trova a b
\r\n	Caratteri di fine della riga Nell'editor ST, le righe finiscono con "\r\n" (un ritorno a capo seguito da una nuova riga). Questi caratteri non sono visibili ma sono presenti nell'editor ST e possono essere cercati. Vedere opzione: Altro > Opzioni > Opzioni programma > Editor > Testo Strutturato (ST) -> Visualizza fine riga	`test\r\n` trova test(CR)(LF)
`.`	Qualsiasi carattere singolo comprendente caratteri di spazio, caratteri di tabulazione e caratteri di linea(CR)(LF)	`te.t1` trova text1 o test1
\	I seguenti caratteri speciali utilizzati nelle espressioni regolari devono essere preceduti da caratteri di escape con il simbolo \ (barra rovesciata) se si desidera cercarli come testo: ^ $ \ . * + ? ( ) [ ] { } \| Non sono ammessi caratteri di escape che formano una delle sequenze di caratteri speciali sopra elencate.	`test\(` trova test(
[classe]	Il carattere di destinazione fa parte della classe di caratteri (vedere le classi di caratteri qui sotto)	`[abc]` trova a, b o c
[^classe]	Il carattere di destinazione non fa parte della classe di caratteri (vedere le classi di caratteri qui sotto).	`[^xyz]` trova qualsiasi carattere ad eccezione di x, y o z

Argomenti correlati

Classi di caratteri

Quantificatori

I quantificatori seguono un carattere o un carattere speciale di modello. Possono modificare il numero di volte in cui un carattere viene ripetuto nella corrispondenza:

Quantificatore	Numero di corrispondenze	Esempio
+	1 o più	`pla+ce` trova place o plaace
*	0 o più	`pla*ce` trova plce o place o plaace
?	0 o 1	`pla?ce` trova plce o place
{int}	Esattamente il numero definito da int	`tyco{3}n` trova tycooon
{int,}	Il numero definito da int o più	`tyco{2,}n` trova tycoooon
{min,max}	Il numero tra min (minimo) e max (massimo)	`tyco{1,2}n` trova tycon o tycoon

Per default, tutti questi quantificatori sono greedy (ovvero prendono tutti i caratteri necessari per soddisfare la condizione il più possibile). Questo comportamento può essere modificato in non greedy (cioè prendere il minor numero possibile di caratteri che soddisfano la condizione) aggiungendo un punto interrogativo (?) dopo il quantificatore.

Quantificatore	Numero di corrispondenze	Esempio
+?	1 o più caratteri, ricerca non greedy	Modello di ricerca: `'.+?'` Testo esempio: sVar1 := 'abc'; sVar2 := 'ABC'; sVar3 := ''; Risultato di ricerca: 'abc' e 'ABC' Viene trovato il minor numero possibile di caratteri tra la prima virgoletta singola e la virgoletta singola successiva.
+	1 o più caratteri, ricerca greedy	Modello di ricerca: `'.+'` Testo esempio: sVar1 := 'abc'; sVar2 := 'ABC'; sVar3 := ''; Risultato di ricerca: 'abc'; sVar2 := 'ABC'; sVar3 := '' Viene trovato il maggior numero possibile di caratteri tra la prima virgoletta singola e l'ultima virgoletta singola.
*?	0 o più caratteri, ricerca non greedy	Modello di ricerca: `'.*?'` Testo esempio: sVar1 := 'abc'; sVar2 := 'ABC'; sVar3 := ''; Risultato di ricerca: 'abc' e 'ABC' e ''
*	0 o più caratteri, ricerca greedy	Modello di ricerca: `'.*'` Testo esempio: sVar1 := 'abc'; sVar2 := 'ABC'; sVar3 := ''; Risultato di ricerca: 'abc'; sVar2 := 'ABC'; sVar3 := ''

Gruppi

I gruppi permettono di applicare i quantificatori a una sequenza di caratteri (invece che a un singolo carattere).

Gruppo di caratteri	Descrizione	Esempio
(sottoespressione)	Cattura i caratteri che rappresentano la sottoespressione nella sequenza obiettivo e li memorizza come un submatch. Ogni submatch è numerato secondo l'ordine di comparizione della parentesi di apertura (il primo submatch è numero di backreference 1, il secondo è numero di backreference 2 e così via...). Il numero di backreference può essere riutilizzato nel campo della ricerca o della sostituzione.	`i(\d)Var\1` trova i1Var1, i2Var2 o i6Var6 ma non i1Var2 (\d) è la sottoespressione della prima cifra trovata che crea il primo backreference (N=1). Questo backreference viene utilizzato con \1 per identificare lo stesso contenuto trovato nel backreference.
(?:sottoespressione)	Definisce un gruppo non di cattura	`i(?:\d)Var(\d)Value\1` trova i1Var2Value2 o i1Var3Value3 In questo caso ci si riferisce con `\1` al primo backreference `(\d)`.
\number	Definisce un backreference che consente a una sottoespressione che ha già una corrispondenza precedente di essere identificata successivamente nella stessa espressione regolare.	Esempio 1: Modello di ricerca: `[a-c](\d)(?:in\|out)put_\1` trova a1input_1 o b2output_2 Spiegazione del modello di ricerca: `[a-c]` trova a, b o c `(\d)` seguito da una cifra e questa cifra è utilizzata come backreference `(?:in\|out)` seguito da in o out, questa espressione non è utilizzata come backreference `put_` seguito da put_ `\1` seguito dal primo backreference
\number	I backreference possono essere utilizzati anche nella stringa di sostituzione.	Esempio 2: Modello di ricerca: `iCount(\d)` trova iCount seguito da una cifra e questa cifra è utilizzata come backreference Modello di sostituzione: `iValue\1` sostituisce la stringa di ricerca iCount con iValue seguito dal primo backreference Il risultato con backreference è, ad es., 3: iCount3 viene sostituito da iValue3

Asserzioni

Le asserzioni specificano una posizione nella stringa in cui deve verificarsi una corrispondenza. Quando si utilizza un'asserzione nell'espressione di ricerca, il motore dell'espressione regolare non avanza attraverso la sequenza di destinazione né consuma caratteri, ma cerca una corrispondenza solo nella posizione specificata.

Gruppo di caratteri	Descrizione	Esempio
\b	Limite di parola	`\bis` trova island e is ma non This `is\b` trova This e is ma non island `\bis\b` trova is ma non island
\B	Non un limite di parola	`\Bis` trova This ma non island `is\B` trova island ma non This `\Bis\B` trova Wish ma non is o island
^	Inizio della riga	`^iVar` trova iVar solo se la stringa di ricerca inizia con una nuova riga. Utilizzare `^\s*iVar` per trovare iVar con gli spazi vuoti all'inizio della riga. Tip Premendo il tasto dell'accento circonflesso <^> seguito da una vocale, ad esempio a, e, i, o, il simbolo verrà interpretato come un accento circonflesso, ovvero â, ê, î, ô, û. Per evitarlo, premere <^> seguito da uno spazio.
$	Fine della riga	`iVar$` trova iVar solo se la stringa di ricerca termina in una riga.
(?=sottoespressione)	Lookahead positivo I caratteri che seguono l'asserzione devono corrispondere alla sottoespressione, ma non viene consumato alcun carattere.	`Var(?=\d)` trova tutte le Var seguite da una cifra
(?!sottoespressione)	Lookahead negativo I caratteri che seguono l'asserzione non devono corrispondere alla sottoespressione, ma non viene consumato alcun carattere.	`Var(?!\d)` trova tutte le Var non seguite da una cifra

Alternative

Un modello può includere diverse alternative:

Carattere	Descrizione	Esempio
\|	Separatore che separa due modelli o sottoespressioni alternativi.	`(i\|o)Var` trova iVar o oVar

Per utilizzare più modelli alternativi in un'espressione regolare, separarli con l'operatore separatore (|): L'espressione regolare corrisponde se una qualsiasi delle alternative corrisponde e non appena una corrisponde.

Anche le sottoespressioni (nei gruppi o nelle asserzioni) possono usare l'operatore di separazione per separare le diverse alternative.

Classi di caratteri

Una classe di caratteri definisce un insieme di caratteri racchiusi tra parentesi quadre [ ].

L'oggetto espressione regolare tenta di far corrispondere l'intera classe di caratteri a un singolo carattere della sequenza di destinazione (a meno che un quantificatore non specifichi diversamente).

La classe di caratteri può contenere qualsiasi combinazione di:

Tipo	Descrizione	Esempio
Singoli caratteri	Qualsiasi carattere specificato è considerato parte della classe (tranne i caratteri speciali - (trattino), [ (parentesi quadra sinistra) e ] (parentesi quadra destra). All'interno di una classe di caratteri possono essere utilizzati anche tutti i caratteri speciali di modello come \t, \d, ecc.	`[abc]` trova a, b o c `[^xyz]` trova qualsiasi carattere ad eccezione di x, y o z
Intervallo	Per specificare un intervallo, inserire il - (trattino) tra due caratteri validi.	`[a-z]` trova tutti i caratteri minuscoli nella gamma da a a z. `[^D-F]` trova qualsiasi carattere maiuscolo ad eccezione della lettera D, E o F. `[1-36-9]` trova una cifra da 1 a 3 o da 6 a 9 `[abc1-5]` trova a, b o c o una cifra da 1 a 5.
Caratteri di escape	I caratteri -]\^ hanno un significato speciale nelle definizioni della classe di caratteri. Per trattare questi caratteri come caratteri normali, aggiungere una barra rovesciata prima dei caratteri per eliminare il loro significato speciale.	`[a\-z]Var` trova aVar, -Var o zVar `[ab\t\]]` trova a, b, scheda o ]

Tipo

Descrizione

Esempio

Singoli caratteri

Qualsiasi carattere specificato è considerato parte della classe (tranne i caratteri speciali - (trattino), [ (parentesi quadra sinistra) e ] (parentesi quadra destra).

All'interno di una classe di caratteri possono essere utilizzati anche tutti i caratteri speciali di modello come \t, \d, ecc.

[abc] trova a, b o c

[^xyz] trova qualsiasi carattere ad eccezione di x, y o z

Intervallo

Per specificare un intervallo, inserire il - (trattino) tra due caratteri validi.

[a-z] trova tutti i caratteri minuscoli nella gamma da a a z.

[^D-F] trova qualsiasi carattere maiuscolo ad eccezione della lettera D, E o F.

[1-36-9] trova una cifra da 1 a 3 o da 6 a 9

[abc1-5] trova a, b o c o una cifra da 1 a 5.

Caratteri di escape

I caratteri -]\^ hanno un significato speciale nelle definizioni della classe di caratteri. Per trattare questi caratteri come caratteri normali, aggiungere una barra rovesciata prima dei caratteri per eliminare il loro significato speciale.

[a\-z]Var trova aVar, -Var o zVar

[ab\t\]] trova a, b, scheda o ]