regular expression

Premessa:
Allora, le regular expression, sono una specie di sub-linguaggio di programmazione, che consente di ottenere risultati
strabilianti con pochissime righe di codice.
Allora, le regular expressions sono supporttate da quasi tutti i linguaggi di programmazione dal c al .net dal php ad asp.net ed
altro. Alcuni linguaggi di programmazione richiedono una libreria esterna per utilizzare questo "linguaggio", invece altri (come
il .net) hanno questa funzionalità già incorporata nel compilatore.
Teoria
Allora, le regular expression (in italiano: Espressioni Regolari) sono un linguaggio, che viene utilizzato moltissimo, anche in
molti programmi. La loro funzione principale, è quella di eseguire una ricerca di una stringa all'interno di un testo, ma voi
direte, ke *****a, questo si poteva fare anche con le funzioni di vb (o del linguaggio che preferite), ma se voi volete
convalidare una email in vb.net, quanto codice dovete scrivere? un bel po. invece con le regular expressions, basta una
semplice pattern di ricerca, ecco quella utilizzata: ^[a-zA-Z][\w\.-]*[a-zA-Z0-9]@[a-zA-Z0-9][\w\.-]*[a-zA-Z0-9]\.[a-zA-Z][azA-Z\.]*[a-zA-Z]$
poco comprensibile? bè arriveremo pian piano a capirla.
In questa guida io descriverò le regular expression del .net framework, ma maggior parte dei concetti valgono anche per gli
altri linguaggi.
Vediamo inanzitutto quali caratteri (e metacaratteri) utilizza questo linguaggio:

* Caratteri di escape
* Classi di caratteri
* Sostituzioni
* Asserzioni atomiche di ampiezza zero
* Quantificatori
* Costruttori di raggruppamento
* Costruttori di riferimento
* Costruttori di alternanza
* Costruttori vari
I caratteri di escape vengono usati per il confronto di singoi caratteri.
Cratteri di escape:
\b Rappresenta il carattere BackSpace, solo se utilizzato in una parentesi quadra, altrimenti rappresenta il limite di una parola
(inizio o fine)
\t Rappresenta il carattere di tabulazione
\r Rappresenta il carattere di ritorno carrello ( o meglio detto: ritorno a capo)
\v Rappresenta il carattere di tabulazione verticale
\n Rappresenta il carattere di nuova riga (quello usato in molti linguaggi di programmazione, come PHP, C, ecc...)
\e Rappresenta il carattere di escape
\* Quanto il carattere escape è seguito da un carattere (che non sia uno dei sopraccitati) rappresenta il carattere stesso. (es: \z =
z)
Una classe di caratteri permette di confrontare un gruppo di caratteri con un insieme di caratteri specificati es: [aeiou]
corrisponde a tutte le vocali. Gli unici due caratteri che hanno un significato speciale all'interno di un insieme sono il trattino '-'
e il carattere di chiusura della parentesi quadra ']'.
Classi di caratteri:
. (il punto) Rappresenta un qualsiasi carattere apparte quello \n, invece se viene specificata l'opzione SingleLine, il punto
corrispode a qualsiasi carattere compreso \n (per ulteriori informazioni sulle opzioni delle regular expression, vedere il
paragrafo su questa pagina)
[aeiou] Rappresenta tutti i caratteri compresi nell'insieme.
[^aeiou] Rappresenta tutti i caratteri tranne quelli nell'insieme
[A-Za-z0-9] Il carattere - (detto trattino) consente di specificare un intervallo di caratteri (o numeri). in questo caso l'insieme
corrisponde a tutti i caratteri maiuscoli e caratteri minuscoli e tutti i numeri
\p{nome} Corrisponde a una classe di caratteri con uno specifico nome (dichiarato precedentemente nella regular expression).
\P{nome} Corrisponde a tutti i caratteri tranne a quelli inclusi nel set di caratteri con nome specificato all'interno delle
parentesi graffe.
\w Corrisponde a tutti i caratteri alfanumerici.
\W Corrisponde a tutti i caratteri tranne quelli alfanumerici (notate che questo linguaggio è case-sensitive)
\d Corrisponde a un numero (analogo a [0-9]).
\D Corrisponde a un qualsiasi carattere diverso da un numero.
\s Corrisponde a un carattere spazio.
\S Corrisponde a un qualsiasi carattere tranne il carattere spazio.
Le sostituzioni sono consentite solo all'interno di criteri di sostituzione. I caratteri di escape a quelli delle sostituzioni sono gli
unici caratteri che sono consentiti all'interno di un criterio di sostituzione. (se è difficile capire i seguenti caratteri, studiare i
costruttori di raggruppamento, descritti in seguito).
Sostituzioni:
$numero Sostituisce l'ultima sottostringa corrispondente al numero di un gruppo.
${nome} Sostituisce l'ultima sottostringa corrispondente al nome di un gruppo. (?<nome>)
$$ Sostituisce un singolo carattere.
$_ Sostituisce l'intera stringa di input.
Le asserzioni atomiche di ampiezza zero, indicano dove dovrebbe essere la stringa di confronto, ma non consumano caratteri. $
indica la fina di una stringa, quindi l'espressione Infernet$ corrisponde a qualsiasi parola "Infernet" che sia subito prima della
fine della riga.
Asserzioni atomiche di ampiezza zero:
^ Specifica che la corrispondenza deve trovarsi all'inizio o alla fine di una stringa.
$ Specifica che la corrispondenza deve trovarsi perforza alla fine di una riga, prima di \n oppure al termine della stringa.
(vedere l'esempio di $Infernet sopraccitato)
\A Specifica che la corrispondenza deve essere perforza all'inizio di una riga.
\Z Specifica che la corrispondenza deve trovarsi alla fine di una stringa subito prima di \n.
\z Specifica che la corrispondenza deve essere perforza alla fine di una stringa.
\b Indica il primo e l'ultimo carattere di una parola delimitata da spazi o da simboli di punteggiatura (cioè tra un carattere \w e
\W).
\B Speicfica che la corrispondenza non deve essere su un limite (l'incontrario di \b).
I Quantificatori indicano che una corrispondenza deve verificarsi per un certo numero di volte. ad es: \b[aeiou]+\b corrisponde
a una parola formata solo da vocali.
Quantificatori:
* Indica zero o più corrispondenze.
+ Indica una o più corrispondenze.
? Indica zero o una occorrenza.
{n} Specifica esattamente n occorrenze.
{n,} Specifica almeno n occorrenze.
{n,m} Specifica almeno n occorrenze, ma non più di m.
*? Specifica la prima occorrenza che utilizza il minor numero di ripetizioni. (lazy: *)
+? Specifica il minor numeri di ripetizioni, ma almeno una.
?? Specifica zero ripetizioni, se possibile, oppure una.
{n,} Specifica il minor numero di ripetizioni, ma almeno n
{n,m}? Specifica il minor numero di ripetizioni, ma copreso tra n e m
I Costruttori di raggruppamento permettono di raggruppare le espressioni regolari e di accrescere l'efficienza delle espressioni.
(Per maggiori informazioni visitare: http://msdn2.Micro$oft.com/it-it/library/bs2twtah(VS.80).aspx)
Costruttori di raggruppamento:
(exp) Acquisisce la sottostringa rappresentata, le acquisisce un numero (che viene generato automaticamente partendo da uno)
(?<nome> Acquisisce la sottostringa e gli assegna un nome.
(?: ) Gruppo di non acquisizione.
I Costruttori di riferimento all'indietro consentono di referenziare un precedente gruppo di acquisizione attraverso il numero o
il nome del gruppo.
Costruttori di riferimento all'indietro:
\numero Riferimento all'indietro ad un gruppo precedentemente dichiarato usando il numero del gruppo.
\k<nome> Riferimento all'indietro ad un gruppo precedentemenete dichiarato usando il nome del gruppo.
I Costruttori di alternanza forniscono un modo per specificare alternative.
Costruttori di alternanza:
| Corrispone a uno dei termini separati dal carattere '|', ad es: Infernet|X|Security|Team, prevale la parola più a sinistra.
(?( expression )yes|no) Se l'espressione passata trova qualche corrispondenza allora si esegue la parte yes, altrimenti la parte
no (il classco if-else-end if)
(?(name)yes|no) Utilizza un riferimento all'indietro per valutare il gruppo, e poi valuta yes o no
I Costruttori vari sono specifiche Regular Expression che permettono di eseguire il codice in un modo piuttosto che in un'altro,
specificando delle opzioni.
Costruttori vari:
(?imnsx-imnsx) Attiva o disattiva un'opzione.
(?#Commento) Permette di inserire commenti nel codice.
#[Commento fino alla fine della riga] Permette di inserire un commento alla fine del codice (il codice Regular Expression
dopo questo carattere, verrà ignorato).
Optioni delle regular expression: disponibili a questa pagina: http://msdn2.Micro$oft.com/it-it/library/yd1hzczs(VS.80).aspx
Eccoci giunti alla fine dell'articolo, questo è il mio primo articolo sulle Regular Expression, sono sicuro che ne scriverò
un'altro che definisce la parte pratica (cioè come utilizzare le regular expression), per ora fidatevi di Goog1e!.