[PHP] Piccola guida alle espressioni regolari

Guardando il topic in rilievo in questa sezione, me la sono sentita: scrivo una piccola guida (in italiano )

Dunque, le espressioni regolari (o REGular EXPressions, regexp) servono ad eseguire varie funzioni. Dal replace di un pattern, alla ricerca di una stringa, alla presenza di un pattern in un'altro.
Piccola lezione sul lessico:
1) Pattern: criterio
2) Stringa: gruppo di caratteri non solo numerici (spero che conosciate già questo termine)
3) Replace: sostituzione
4) Engine: motore

Cominciamo. Spiegherò solo le funzioni principali, ovvero
preg_match - controlla che testo corrisponda a pattern
preg_replace - sostituisce testo corrispondente con pattern con replace

Sintassi delle espressioni regolari.

Le espressioni regolari sono frutto di immaginazione e combinazione dei vari elementi che le compongono. Facciamo un semplicissimo esempio di codice da trattare con preg_match.

<?php
$testo = 'Marco è uscito, è andato a mare..';
$pattern = '/[a-zA-Z0-9]*.*(uscito){1}.*(mare){1,}(\.){1,2}/';
echo preg_match($pattern, $testo);
?>

Nulla di tanto speciale, in parole umane la nostra espressione regolare vuol dire
Lettere e numeri, da 0 caratteri in poi; qualunque carattere da 0 caratteri in poi, uscito, ripetuto una volta; qualunque carattere, da 0 caratteri in poi, un punto, ripetuto una o due volte.
Teoricamente, questo codice, dovrebbe far sì che il risultato restituito da preg_match sia TRUE, quindi a video sia visualizzato 1.
Ora analizziamo bene l'espressione regolare: il carattere / all'inizio, come potete constatare, è anche presente alla fine. Esso sta ad indicare all'engine delle PCRE dove inizia l'espressione regolare e dove finisce.
Vi starete chiedendo: perchè servono quei caratteri quando la stringa è già delimitata? Risposta: dopo il carattere finale dell'espressione possono essere inseriti i "Pattern Modifiers", Modificatori di criterio.
Comunque, / non è l'unico carattere che si può inserire. Possiamo anche inserire un qualunque altro carattere come # @ % ecc. Passiamo ora alle altre parti del pattern. [a-z][A-Z][0-9]. [a-z] sta ad indicare un
qualunque carattere dalla a alla z (minuscolo, come si può comprendere), mentre [A-Z] svolge lo stesso ruolo con i caratteri maiuscoli. Si può definire quindi che utilizzando il modificatore di criterio i basterebbe scrivere a-z per far prendere in considerazione all'engine
anche le lettere maiuscole. Andiamo avanti, carattere *: esso sta ad indicare {0,} ovvero da 0 caratteri in poi. Per comprendere meglio, spieghiamo la funzione del punto . esso sta ad indicare un qualunque carattere (eccetto ritorno di riga e carattere a capo e \a, che si possono abilitare
col modificatore s. Per comprendere meglio, si può fare un esempio pratico (ricorrente in mIRC Scripting e pattern contenenti wildcard *). La wildcard * si "traduce" in espressione regolare come .*, cioè qualunque carattere per una lunghezza totale da 0 in poi (quindi se si riconosce
la stringa "ciao mi chiamo Marco" con il pattern "ciao*Marco*", il risultato sarà TRUE).

Spieghiamo dunque approfonditamente le funzioni delle [quadre] e delle {graffe} facendo un pratico esempio:
[a-z] qualunque lettera dalla a alla z
[A-Z] qualunque lettera dalla A alla Z (maiuscola)
[0-9] qualunque numero dallo 0 al 9 (quindi se associato a * vengono anche considerati numeri come 10, 1599 ecc..)
[a-f] qualunque lettera dalla a alla F
[5-8h-p] qualunque numero dal 5 all'8 e qualunque lettera dalla h alla p
[a-zA-Z0-9] qualunque lettera dalla a alla z (anche maiuscole) e numeri dal 0 al 9.
[^a-z] nessuna lettera dalla a alla z (il ^ all'inizio serve a negare l'insieme)
{0,} equivalente di *, sta per dire da 0 caratteri in poi
{1,} equivalente di + (indicato successivamente), sta ad indicare da un carattere in poi
{4,7} sta ad indicare "da 4 a 7"
{,7} massimo 7 caratteri
{4} 4 caratteri precisi

La funzione delle parentesi () è piuttosto semplice da intuire, servono solo degli esempi pratici per comprendere meglio. Sostanzialmente serve in espressioni del tipo (ciao)* in modo che l'engine riconosca la parola ciao ripetuta almeno 0 volte.
Come accennato prima, oltre al *, esiste anche un'altro "puntatore", esso è + (ovvero {1,}).
Ovviamente, nelle espressioni regolari, sono validi gli escape \.
I caratteri | all'interno del pattern sono il bitwise OR

Smanettiamo ora con le funzioni...con alcuni esempi di codice si capirà meglio

<?php
preg_match('/[a-z0-9]{2,5}/', 'j'); //FALSE
preg_match('/[a-z0-9]{2,5}/', 1); //FALSE
preg_match('/[a-z0-9]{2,5}/', 'abc'); //Se il cervello non inganna, TRUE :D
preg_match('/[0-9]+/', 0); //TRUE, basta intuire che l'engine considera che c'è anche un solo elemento
preg_match('/[0-9]+/', NULL); //Stavolta è FALSE
preg_match('/[0-9]+/', 'jk'); //FALSE
//Passiamo al preg_replace con gli esempi pratici, more simple
echo preg_replace('/[a-z]*([0-9])*[a-z]*/', '\\1', 'abc9abc'); //9
echo preg_replace('/[a-f]*([j-o])*[a-f]*/', '\\1', 'dblmae'); //m
//Buone espressioni regolari per la sostituzione del BBcode
echo preg_replace('/\[b\](.*)\[\/b\]/', '<b>\\1</b>', '[b]bold[/b]');
echo preg_replace('/\[i\](.*)\[\/i\]/', '<i>\\1</i>', '[i]italic[/i]');
?>

Ovviamente, una guida più accurata e precisa è reperibile su php.net.

Spero di esser stato chiaro nella guida e di non averla resa pesante..Dopotutto le espressioni regolari sono solo dei lego con cui bisogna saperci giocare