2.14. Sintassi delle espressioni regolari

Contenuto

1. Introduzione

2. Corrispondenza semplice

3. Sequenze di escape

4. Classi di caratteri

5. Metacaratteri

5.1. Metacaratteri - Separatori di riga

5.2. Metacaratteri - Classi predefinite

5.3. Metacaratteri - Confini delle parole

5.4. Metacaratteri - Iteratori

5.5. Metacaratteri - Alternative

5.6. Metacaratteri - Sottoespressioni

5.7. Metacaratteri - Riferimenti retroattivi

6. Asserzioni (Lookahead e Lookbehind)

7. Gruppi non catturanti

8. Gruppi atomici

9. Categorie Unicode

10. Modificatori

1. Introduzione

Le espressioni regolari rappresentano un metodo ampiamente utilizzato per definire schemi di ricerca testuale. Caratteri speciali (denominati metacaratteri) consentono di specificare, ad esempio, che una determinata stringa cercata debba apparire all'inizio o alla fine di una riga, o che debba contenere n occorrenze di un carattere o gruppo di caratteri.

Double Commander supporta le espressioni regolari nelle seguenti funzionalità:

• Trova file (ricerca per nome file o contenuto)
• Nello Strumento rinomina multipla
• Nell'editor interno
• Nel visualizzatore interno

La libreria TRegExpr supporta due modalità operative: ANSI e Unicode. Durante la ricerca all'interno dei file di testo, Double Commander le utilizza entrambe (in base alla codifica del file). Durante la ricerca per nome dei file, viene utilizzata la codifica Unicode.

(Torna su)

2. Corrispondenza semplice

Qualsiasi singolo carattere corrisponde a se stesso, a meno che non si tratti di un metacarattere con un significato speciale descritto di seguito.

Una sequenza di caratteri corrisponde alla stessa sequenza nella stringa di destinazione, pertanto il criterio bluh corrisponderà a bluh nella stringa target.

Possiamo far sì che i metacaratteri o le sequenze di escape vengano interpretati alla lettera facendoli precedere da una barra rovesciata \: ad esempio, il metacarattere ^ corrisponde all'inizio della riga, ma \^ corrisponde al carattere letterale ^, \\ corrisponde a \, e così via.

Ecco alcuni esempi:

(Torna su)

3. Sequenze di escape

I caratteri possono essere specificati utilizzando una sintassi per le sequenze di escape analoga a quella impiegata in C e Perl: \n corrisponde a un carattere di nuova riga, \t corrisponde a una tabulazione, ecc.

Più in generale, \xnn, dove nn è una sequenza di cifre esadecimali, corrisponde al carattere con valore ASCII nn.

Se si necessita di codici di caratteri estesi (Unicode), è possibile utilizzare \x{nnnn}, dove nnnn rappresenta una o più cifre esadecimali.

Ecco alcuni esempi:

(Torna su)

4. Classi di caratteri

È possibile specificare una classe di caratteri racchiudendo l'elenco dei caratteri tra parentesi quadre []; questo consentirà di far corrispondere a tale elemento qualsiasi singolo carattere presente nell'elenco.

Se il primo carattere dopo [ è ^, allora la classe corrisponderà a qualsiasi carattere non presente nell'elenco.

All'interno dell'elenco, il carattere - viene utilizzato per definire un intervallo: ad esempio, a-z indica tutti i caratteri compresi tra a e z, estremi inclusi.

Se si desidera includere il carattere - letterale nella classe, è necessario posizionarlo all'inizio o alla fine dell'elenco, oppure farlo precedere da una barra rovesciata.

Se si desidera includere il carattere ], è possibile posizionarlo all'inizio dell'elenco o farlo precedere da una barra rovesciata.

Ecco alcuni esempi:

(Torna su)

5. Metacaratteri

I metacaratteri rappresentano l'essenza delle espressioni regolari e sono caratteri speciali.

Esistono diverse tipologie di metacaratteri, descritte di seguito.

(Torna su)

5.1. Metacaratteri - Separatori di riga

Alcune espressioni aiutano a rilevare i separatori di riga.

Ecco alcuni esempi:

Per impostazione predefinita, il metacarattere ^ corrisponde esclusivamente all'inizio della stringa/testo di input, mentre il metacarattere $ corrisponde esclusivamente alla fine. I separatori di riga incorporati all'interno della stringa non corrispondono a ^ o $.

Tuttavia, si potrebbe desiderare di trattare la stringa come un buffer multilinea: in questo caso, ^ corrisponderà dopo qualsiasi separatore di riga all'interno della stringa e $ corrisponderà prima di qualsiasi separatore di riga. È possibile ottenere questo comportamento attivando il modificatore m.

\A e \Z si comportano in modo analogo a ^ e $, ma quando si utilizza il modificatore m essi non effettueranno corrispondenze multiple, a differenza di ^ e $ che invece corrisponderanno a ciascun separatore di riga interno.

Per impostazione predefinita, il metacarattere . corrisponde a qualsiasi carattere, ma se si disattiva il modificatore s, allora . non corrisponderà ai separatori di riga incorporati.

TRegExpr gestisce i separatori di riga in conformità con lo standard tecnico Unicode (Technical Standard #18):

• ^ corrisponde all'inizio della stringa di input e, se il modificatore m è attivo, anche dopo qualsiasi occorrenza di \x0D\x0A, \x0A o \x0D (in Unicode supporta anche: \x2028, \x2029, \x0B, \x0C o \x85). Si noti che non viene rilevata alcuna riga vuota all'interno della sequenza \x0D\x0A.

• $ corrisponde alla fine della stringa di input e, se il modificatore m è attivo, anche prima di qualsiasi occorrenza di \x0D\x0A, \x0A o \x0D (in Unicode supporta anche: \x2028, \x2029, \x0B, \x0C o \x85). Si noti che non viene rilevata alcuna riga vuota all'interno della sequenza \x0D\x0A.

• . corrisponde a qualsiasi carattere, ma se si disattiva il modificatore s, allora . non corrisponderà a \x0D\x0A, \x0A e \x0D (in Unicode non corrisponde nemmeno a: \x2028, \x2029, \x0B, \x0C o \x85).

Si noti che la formula ^.*$ (criterio per riga vuota) non corrisponderà a una stringa vuota all'interno della sequenza \x0D\x0A, ma vi corrisponderà nella sequenza \x0A\x0D.

(Torna su)

5.2. Metacaratteri - Classi predefinite

Alcune espressioni aiutano a rilevare specifici gruppi di caratteri.

È possibile utilizzare \w, \d e \s all'interno di classi di caratteri personalizzate.

Ecco alcuni esempi:

(Torna su)

5.3. Metacaratteri - Confini delle parole

Un confine di parola (\b) rappresenta la posizione compresa tra due caratteri in cui uno è di tipo \w e l'altro è di tipo \W (in qualsiasi ordine), considerando l'inizio e la fine immaginari della stringa come caratteri corrispondenti a \W.

(Torna su)

5.4. Metacaratteri - Iteratori

Qualsiasi elemento all'interno di un'espressione regolare può essere seguito da un altro tipo di metacarattere: l'iteratore.

Utilizzando questi metacaratteri, è possibile specificare il numero di occorrenze del carattere, metacarattere o sottoespressione precedente.

Pertanto, i numeri all'interno delle parentesi graffe nella forma {n,m} specificano il numero minimo di volte n e il numero massimo di volte m che l'elemento deve corrispondere.

La forma {n} equivale a {n,n} e corrisponde esattamente a n volte.

La forma {n,} corrisponde a n o più volte.

Non vi sono limiti alla grandezza di n o m, tuttavia valori elevati possono rallentare l'esecuzione e consumare più memoria.

Se le parentesi graffe appaiono in qualsiasi altro contesto, verranno trattate come caratteri normali.

Ecco alcuni esempi:

Una breve spiegazione sul comportamento "greedy" (avido).

La modalità "greedy" acquisisce la massima quantità possibile di elementi, mentre la modalità "non-greedy" ne acquisisce la minima quantità possibile.

Ad esempio, applicando b+ e b* alla stringa abbbbc si otterrà bbbb, mentre con b+? si otterrà b, con b*? si otterrà una stringa vuota, con b{2,3}? si otterrà bb e con b{2,3} si otterrà bbb.

È possibile impostare tutti gli iteratori in modalità "non-greedy" (si veda il modificatore g).

(Torna su)

5.5. Metacaratteri - Alternative

È possibile utilizzare il carattere | per separare una serie di alternative all'interno di un criterio di ricerca, in modo che fee|fie|foe corrisponda a fee, fie o foe nella stringa target (lo stesso vale per f(e|i|o)e).

La prima alternativa include tutto ciò che si trova tra il delimitatore di criterio precedente ((, [ o l'inizio del criterio) e il primo carattere |, mentre l'ultima alternativa include tutto ciò che si trova tra l'ultimo carattere | e il delimitatore di criterio successivo.

Pertanto, rappresenta una buona norma racchiudere le alternative tra parentesi per ridurre al minimo la confusione in merito ai loro punti di inizio e fine.

Le alternative vengono valutate da sinistra a destra, pertanto verrà scelta la prima alternativa che consente la corrispondenza dell'intera espressione.

Ciò significa che le alternative non sono necessariamente di tipo greedy.

Ad esempio: confrontando il criterio foo|foot con la stringa barefoot, solo la parte foo corrisponderà, in quanto rappresenta la prima alternativa valutata e la sua corrispondenza ha avuto successo. (Questo comportamento potrebbe non essere rilevante qualora si utilizzino le parentesi per catturare il testo corrispondente).

Si ricordi inoltre che il carattere | all'interno delle parentesi quadre viene interpretato alla lettera: pertanto, scrivendo [fee|fie|foe], la corrispondenza avverrà esclusivamente con i caratteri [feio|].

Esempio:

(Torna su)

5.6. Metacaratteri - Sottoespressioni

La struttura tra parentesi ( ... ) può essere utilizzata anche per definire sottoespressioni di un'espressione regolare.

Una volta eseguita la ricerca, è possibile richiamare qualsiasi sottoespressione o utilizzarla come maschera.

Le sottoespressioni vengono numerate da sinistra a destra in base alla parentesi aperta corrispondente.

La prima sottoespressione è numerata come 1, ed è supportato un massimo di 90 sottoespressioni (l'intera espressione regolare corrispondente è identificata con il numero 0 e può essere richiamata tramite $0 o $&).

Ecco alcuni esempi:

Note relative al modello "Sostituisci con":

• Se si desidera inserire i caratteri letterali $ o \ nel modello, farli precedere da \.
  Esempio: 1\$ is $2\\rub\\ restituirà 1$ is <subexpr2>\rub\.
• Se si desidera inserire una cifra numerica subito dopo $n, è necessario racchiudere n tra parentesi graffe {}.
  Ad esempio, a$12bc restituirà a<subexpr12>bc, mentre a${1}2bc restituirà a<subexpr1>2bc.

Esempio:

Proviamo a invertire la data 21.01.2018 in 2018.01.21:
  Cerca: (\d{2})\.(\d{2})\.(\d{4})
  Sostituisci con: $3.$2.$1

(Torna su)

5.7. Metacaratteri - Riferimenti retroattivi

I metacaratteri da \1 a \9 vengono interpretati come riferimenti retroattivi (backreference). Il codice \n corrisponde alla sottoespressione n precedentemente individuata.

Ecco alcuni esempi:

(Torna su)

6. Asserzioni (Lookahead e Lookbehind)

Lookahead positivo: foo(?=bar) corrisponde a foo solo se seguito da bar, ma la parte bar non verrà inclusa nella corrispondenza.

Lookahead negativo: foo(?!bar) corrisponde a foo solo se non è seguito da bar.

Lookbehind positivo: (?<=foo)bar corrisponde a bar solo se preceduto da foo, ma la parte foo non verrà inclusa nella corrispondenza.

Lookbehind negativo: (?<!foo)bar corrisponde a bar solo se non è preceduto da foo.

Limitazioni:

• Le parentesi di lookahead devono essere posizionate alla fine dell'espressione, mentre le parentesi di lookbehind devono essere all'inizio. Pertanto, non sono supportate asserzioni all'interno di scelte separate da | o all'interno di gruppi.

• Per il lookbehind (?<!foo)bar, l'espressione regolare foo deve essere di lunghezza fissa (ovvero deve corrispondere solo a elementi con lunghezza costante). Non è consentito l'uso di quantificatori, ad eccezione delle parentesi graffe con cifre di ripetizione fisse {n} o {n,n}. In questa sede sono ammesse le classi di caratteri, l'uso del punto, nonché \b e \B. Non sono invece ammessi gruppi e scelte.

• Per le altre tre tipologie di asserzione, l'espressione all'interno delle parentesi può presentare qualsiasi livello di complessità.

(Torna su)

7. Gruppi non catturanti

Sintassi: (?:expr).

Questa tipologia di gruppo non dispone di un "indice" e non risulta visibile ai riferimenti retroattivi. Si utilizzano i gruppi non catturanti qualora si desideri raggruppare delle sottoespressioni senza tuttavia memorizzarle come parte catturata o corrispondente della stringa. L'impiego dei gruppi non catturanti consente di velocizzare l'elaborazione delle espressioni regolari.

(Torna su)

8. Gruppi atomici

Sintassi: (?>expr|expr|...).

I gruppi atomici rappresentano un caso speciale di gruppi non catturanti: se una parte dello schema viene individuata, questa tipologia di raggruppamento disabilita il backtracking all'interno del gruppo tra parentesi. I gruppi atomici operano in modo estremamente rapido e si rivelano molto utili per ottimizzare gruppi contenenti svariate espressioni differenti.

Ad esempio, il criterio a(bc|b)c corrisponde a abcc e abc, mentre a(?>bc|b)c corrisponde a abcc ma non a abc, poiché al motore viene vietato di effettuare il backtracking per tentare di impostare il gruppo su b.

(Torna su)

9. Categorie Unicode

Lo standard Unicode assegna un nome alle categorie di caratteri, rappresentato da stringhe di due lettere. Ad esempio, Lu indica una lettera maiuscola, mentre Ll indica una lettera minuscola. La categoria principale a singola lettera L comprende invece tutte le lettere.

Il metacarattere \p rappresenta un carattere Unicode appartenente alla categoria specificata. Sintassi: \pL e \p{L} per i nomi a singola lettera, \p{Lu} per i nomi a due lettere.

Il metacarattere \P rappresenta la negazione, indicando un carattere Unicode che non appartiene alla categoria specificata.

Questi metacaratteri sono supportati anche all'interno delle classi di caratteri.

(Torna su)

10. Modificatori

Sintassi per un singolo modificatore: (?i) indica l'attivazione, mentre (?-i) indica la disattivazione. Sono ammessi modificatori multipli, ad esempio: (?msgxr-imsgxr).

I modificatori vengono impiegati per alterare il comportamento dell'espressione regolare. Un modificatore influisce esclusivamente sulla parte dell'espressione regolare che segue l'operatore (?imsgxr-imsgxr).

Ciascuno di questi modificatori può essere incorporato direttamente all'interno dell'espressione regolare. Se un modificatore viene inserito in linea in una sottoespressione, influirà esclusivamente su tale sottoespressione.

i

Esegue la corrispondenza dei criteri senza fare distinzione tra maiuscole e minuscole (utilizzando le impostazioni internazionali di sistema). Disattivato per impostazione predefinita.

m

Tratta la stringa como multilinea. Ovvero, modifica il comportamento di ^ e $ in modo che corrispondano rispettivamente all'inizio o alla fine di qualsiasi riga interna alla stringa, anziché all'inizio o alla fine assoluti dell'intero testo. Si veda anche la sezione Separatori di riga. Disattivato per impostazione predefinita.

s

Tratta la stringa come singola riga. Ovvero, modifica il comportamento del metacarattere . in modo che corrisponda a qualsiasi carattere, compresi i separatori di riga (si veda anche la sezione Separatori di riga), che normalmente verrebbero esclusi. Attivo per impostazione predefinita.

g

Modificatore non standard. Disattivandolo, tutti gli operatori successivi verranno impostati in modalità "non-greedy" (per impostazione predefinita, questo modificatore è attivo). Di conseguenza, se il modificatore g viene disattivato, + opererà come +?, * come *?, ecc.

x

Estende la leggibilità del criterio consentendo l'uso di spazi vuoti e commenti (si veda la spiegazione riportata di seguito). Disattivato per impostazione predefinita.

r

Modificatore non standard. Se attivo, l'intervallo а-я includerà in aggiunta la lettera russa ё, l'intervallo А-Я includerà la lettera Ё, e l'intervallo а-Я comprenderà tutte le lettere russe. Attivo per impostazione predefinita.

#

(?#text): commento, la parte text viene ignorata. Si noti che TRegExpr chiude il commento non appena rileva il carattere ), pertanto non è possibile inserire una parentesi tonda chiusa all'interno del testo del commento.

Ecco alcuni esempi:

Il modificatore x merita una spiegazione più approfondita.

Esso indica di ignorare i caratteri di spazio che non sono preceduti da barra rovesciata e che non si trovano all'interno di una classe di caratteri.

È possibile utilizzarlo per suddividere l'espressione regolare in parti (leggermente) più leggibili.

Anche il carattere # viene trattato come metacarattere per introdurre commenti, ad esempio:

(
  (abc) # Commento 1
    |   # È possibile utilizzare lo spazio per formattare l'espressione regolare: TRegExpr lo ignorerà
  (efg) # Commento 2
)

Questo significa inoltre che se si desidera includere un carattere di spazio letterale o il carattere # nel criterio (al di fuori delle classi di caratteri, dove non sono influenzati dal modificatore x), sarà necessario farli precedere da barra rovesciata o codificarli tramite escape ottale o esadecimale.

Nel complesso, queste funzionalità incrementano in modo significativo la leggibilità delle espressioni regolari.

(Torna su)   it365 Toolbox