Espressioni regolari (RegExp)

Espressioni regolari

La sintassi delle espressioni regolari è considerata superata dallo standard POSIX, ma è comunque molto usata per la sua larga diffusione. La maggior parte dei programmi che utilizzano le regexp, utilizzano queste regole dando anche il supporto per le nuove regole che sono più estese.

Questi sono i  "metacaratteri" che ci permetteranno di effettuare le espressioni di ricerca:

.	Trova un singolo carattere (se è nella modalità linea singola altrimenti se è in multiriga prende tutti i caratteri diversi da \n, ovvero un ritorno a capo).
[ ]	Trova un singolo carattere contenuto nelle parentesi. Ad esempio, [abc] trova o una "a", "b", o "c". [a-z] è un intervallo e trova ogni lettera minuscola dell'alfabeto. Possono esserci casi misti: [abcq-z] trova a, b, c, q, r, s, t, u, v, w, x, y, z, esattamente come [a-cq-z]. Il carattere '-' è letterale solo se è primo o ultimo carattere nelle parentesi: [abc-] o [-abc]. Per trovare un carattere '[' o ']', il modo più semplice è metterli primi all'interno delle parentesi: [][ab] trova ']', '[', 'a' o 'b'.
[^ ]	Trova ogni singolo carattere non incluso nelle parentesi. Ad esempio, [^abc] trova ogni carattere diverso da "a", "b", o "c". [^a-z] trova ogni singolo carattere che non sia una lettera minuscola. Come sopra, questi due metodi possono essere usati insieme.
^	Corrisponde all'inizio della stringa (o di ogni riga della stringa, quando usato in modalità multilinea)
$	Corrisponde alla fine della stringa o alla posizione immediatamente precedente un carattere di nuova linea (o alla fine di ogni riga della stringa, quando usato in modalità multilinea)
( )	Definisce una "sottoespressione marcata". Il risultato di ciò che è incluso nell'espressione, può essere richiamato in seguito. Vedi sotto, \n.
\n	Dove n è una cifra da 1 a 9; trova ciò che la nesima sottoespressione ha trovato. Tale costrutto, detto backreference, estende le potenzialità delle regexp oltre i linguaggi regolari e non è stato adottato nella sintassi estesa delle regexp.
*	Un'espressione costituita da un singolo carattere seguito da "*", trova zero o più copie di tale espressione. Ad esempio, "[xyz]*" trova "", "x", "y", "zx", "zyx", e così via. \n*, dove n è una cifra da 1 a 9, trova zero o più iterazioni di ciò che la nesima sottoespressione ha trovato. Ad esempio, "(a.)c\1*" trova "abcab" e "accac" ma non "abcac". Un'espressione racchiusa tra "\(" e "\)" seguita da "*" non è valida. In alcuni casi (es. /usr/bin/xpg4/grep di SunOS 5.8), trova zero o più ripetizioni della stringa che l'espressione racchiusa ha trovato. In altri casi (es. /usr/bin/grep di SunOS 5.8), trova ciò che l'espressione racchiusa ha trovato, seguita da un letterale "*".
{x,y}	Trova l'ultimo "blocco" almeno x volte e non più di y volte. Ad esempio, "a{3,5}" trova "aaa", "aaaa" o "aaaaa".

Vecchie versioni di grep non supportano il separatore alternativo "|".

Esempi:

".atto" trova ogni stringa di cinque caratteri come gatto, matto o patto

"[gm]atto" trova gatto e matto

"[^p]atto" trova tutte le combinazioni dell'espressione ".atto" tranne patto

"^[gm]atto" trova gatto e matto ma solo all'inizio di una riga

"[gm]atto$" trova gatto e matto ma solo alla fine di una riga

Dal momento che molte serie di caratteri variano a seconda della configurazione locale (in alcuni casi le lettere sono organizzate in abc..xyzABC...XYZ, in altri aAbB..yYzZ), lo standard POSIX ha definito alcune classi o categorie di caratteri come mostrato nella seguente tabella:

classe POSIX	sintassi normale	significato
[:upper:]	[A-Z]	lettere maiuscole
[:lower:]	[a-z]	lettere minuscole
[:alpha:]	[A-Za-z]	lettera sia maiuscole che minuscole
[:alnum:]	[A-Za-z0-9]	numeri e lettere maiuscole e minuscole
[:digit:]	[0-9]	numeri
[:xdigit:]	[0-9A-Fa-f]	numeri in formato esadecimale
[:punct:]	[.,!?:...]	segni di interpunzione
[:blank:]	[ \t]	spazio o TAB
[:space:]	[ \t\n\r\f\v]	caratteri vuoti
[:cntrl:]		caratteri control
[:graph:]	[^ \t\n\r\f\v]	caratteri non vuoti
[:print:]	[^\t\n\r\f\v]	caratteri non vuoti e spazi

Le parentesi quadrate fanno parte della sintassi per indicare la classe di caratteri. Ad esempio [[:upper:][:digit:]ab] trova corrispondenza in una qualsiasi lettera maiuscola, in una qualsiasi cifra, nella lettera 'a' minuscola e nella lettera 'b' minuscola.

Esempi di quantificatori

• * Cerca l'occorrenza (zero o più volte) del carattere o insieme di caratteri cui segue:

abc* identifica ab seguito da zero o più c

come in ab, abc, abcc, abccc

• + Cerca l'occorrenza (una o più volte) del carattere o insieme di caratteri cui segue:

ab[ce]+ identifica ab seguito da una o più c oppure una o più e

come in abc, abec, abccc, abcceeecccccce

• ? Cerca l'occorrenza (zero o una volta) del carattere o insieme di caratteri cui segue:

abc? identifica ab seguito o meno da una c

come in abc e ab

• {m, n} Cerca l'occorrenza (da m a n volte; m lasciato vuoto è zero, n lasciato vuoto infinito) del carattere, insieme di caratteri o sotto-regex cui segue:

(ab){1,2} identifica le sequenze di uno o due ab

come in ab e abab