Le espressioni regolari sono un potente strumento per l’esame e la modifica del testo. Le espressioni regolari se stessi, con una notazione modello generale quasi come un mini linguaggio di programmazione, consentono di descrivere e analizzare il testo. Essi consentono di ricercare pattern all’interno di una stringa, estraendo le partite in modo flessibile e preciso. Tuttavia, si dovrebbe notare che, poiché le espressioni regolari sono più potenti, ma sono anche più lento rispetto alle funzioni stringa più di base. Si dovrebbe usare le espressioni regolari se si ha un bisogno particolare.
Questo tutorial fornisce una breve panoramica di base sintassi delle espressioni regolari e poi considera le funzioni che PHP mette a disposizione per lavorare con le espressioni regolari.
PHP supporta due diversi tipi di espressioni regolari: POSIX-esteso e le espressioni regolari Perl-Compatible (PCRE). Le funzioni PCRE lo sono più potenti di quelli POSIX, e anche più veloce, quindi ci concentreremo su di loro.
Le nozioni di base
In una espressione regolare, la maggior parte caratteri corrispondono solo se stessi. Per esempio, se si cerca l’espressione regolare “pippo” nella stringa “John gioca a calcio,” si ottiene un incontro perché “pippo” si verifica in quella stringa. Alcuni caratteri hanno un significato speciale all’interno delle espressioni regolari. Per esempio, il simbolo del dollaro ($) è usato per abbinare le stringhe che terminano con il modello dato. Analogamente, una (^) accento circonflesso all’inizio di un’espressione regolare indica che deve corrispondere l’inizio della stringa. I caratteri che corrispondono a se stessi sono chiamati letterali. I personaggi che hanno un significato speciale sono chiamati metacaratteri.
La (.) Metacarattere punto corrisponde a qualsiasi singolo carattere tranne newline (). Così, il cappello modello ht partite, hothit, capanna, h7t, ecc tubo verticale (|) viene utilizzato metacarattere alternative in un’espressione regolare. Si comporta proprio come un operatore logico OR e si dovrebbe usare se si vuole costruire un modello che corrisponde a più di un set di caratteri. Per esempio, il modello Utah | Idaho | Nevada partite stringhe che contengono “Utah” o “Idaho” o “Nevada”. Parentesi ci danno un senso alle sequenze di gruppo. Ad esempio, (Nant | b) ucket corrisponde a “Nantucket” o “secchio”. Utilizzando le parentesi per raggruppare i caratteri per l’alternanza si chiama raggruppamento.
Se si desidera far corrispondere un metacarattere letterale in un modello, dovete scappare da un backslash.
Per specificare un set di caratteri accettabili nel vostro modello, è possibile costruire una classe di caratteri o utilizzare uno predefinito. Una classe di caratteri permette di rappresentare un gruppo di personaggi come un unico elemento in un’espressione regolare. È possibile costruire la propria classe di personaggio racchiudendo i caratteri accettabile tra parentesi quadre. Una classe di caratteri corrisponde a uno dei personaggi della classe. Per esempio una classe di caratteri [abc] corrisponde a, b o c. Per definire una serie di caratteri, basta mettere i personaggi in primo e l’ultimo, separati da trattino. Per esempio, per soddisfare tutti i caratteri alfanumerici: [a-zA-Z0-9]. È inoltre possibile creare una classe di caratteri negata, che corrisponde a qualsiasi carattere che non è nella classe. Per creare una classe di caratteri negata, iniziare la classe del personaggio con ^: [^ 0-9].
I metacaratteri +, *,?, E {} influiscono sul numero di volte che un modello dovrebbe essere abbinato. + Significa “la corrispondenza di uno o più dell’espressione precedente”, * significa “la corrispondenza di zero o più dell’espressione precedente”, e? significa “la corrispondenza di zero o uno dell’espressione precedente”. Parentesi graffe {} possono essere usati in modo diverso. Con un singolo intero, {n} significa “corrispondere esattamente n occorrenze dell’espressione precedente”, con un intero e una virgola, {n,} significa “match n occorrenze o più dell’espressione precedente”, e con due separati da virgola interi {n, m} significa “corrisponde al carattere precedente se si verifica almeno n volte, ma non più di m volte”.
Ora, date un’occhiata agli esempi:
Regular Expression Corrisponderà …
pippo La stringa “pippo”
^ Foo “Pippo” all’inizio di una stringa
pippo $ “Pippo” alla fine di una stringa
^ $ Pippo “Pippo” quando è da solo su una corda
[Abc] a, b, oc
[Az] Tutte le lettere minuscole
[^ AZ] Qualsiasi carattere che non è una lettera maiuscola
(Gif | jpg) Partite o “gif” o “jpeg”
[Az] + Una o più lettere minuscole
[0-9 -.] Аny numero, punto, o il segno meno
^ [A-zA-Z0-9_] {1,} $ Ogni parola di almeno una lettera, numero o _
([Wx]) ([yz]) wy, wz, xy, xz o
[^ A-Za-z0-9] Qualsiasi simbolo (non un numero o una lettera)
([AZ] {3} | [0-9] {4}) Partite tre lettere o quattro numeri
Espressioni regolari Perl compatibili emulare la sintassi Perl per i modelli, il che significa che ogni modello deve essere racchiuso in una coppia di delimitatori. Di solito, il (/) carattere barra viene utilizzato. Per esempio, / pattern /.
Le funzioni PCRE possono essere suddivisi in diverse classi: corrispondenza, in sostituzione, scissione e di filtraggio.
Torna in alto
Modelli di corrispondenza
Il preg_match () funzione esegue Perl-stile pattern matching su una stringa. preg_match () accetta due parametri di base e tre opzionali. Questi parametri sono, in ordine, una stringa di espressione regolare, una stringa di origine, un array che memorizza le partite, un argomento bandiera e un parametro di compensazione che può essere utilizzato per specificare il luogo alternativo da cui iniziare la ricerca:
preg_match (modello, soggetto [, fiammiferi [, flags [, offset]]])
Il preg_match () restituisce 1 se viene trovata una corrispondenza e 0 altrimenti. Facciamo ricerca la stringa “Ciao Mondo!” per le lettere “ll”:
if (preg_match (“/ ell /”, “Ciao Mondo”, $ matches)) {
echo “Il riconoscimento è avvenuto
“;
echo $ matches [0];
}
?>
Le lettere “LL” esistono in “Ciao”, così preg_match () restituisce 1 e il primo elemento della variabile $ partite è riempito con la stringa che corrispondeva il motivo. L’espressione regolare nel prossimo esempio sta cercando le lettere “ell”, ma in cerca di loro con i seguenti caratteri:
if (preg_match (“/ ll .*/”,” La storia di Halloween “, $ matches)) {
echo “Il riconoscimento è avvenuto
“;
echo $ matches [0];
}
?>
Ora consideriamo esempio più complicato. L’uso più popolare delle espressioni regolari è la convalida. L’esempio che segue verifica se la password è “forte”, cioè la password deve essere di almeno 8 caratteri e deve contenere almeno una lettera minuscola, una lettera maiuscola e una cifra:
$ Password = “Fyfjk34sdfjfsjq7”; if (preg_match (“/^.*(?=.{ 8 ,})(?=.* d )(?=.*[ az ])(?=.*[ AZ] ).*$/”, $ password)) { echo “La tua password è forte.”; } else { echo “La password è debole.”; } ?>
I ^ e $ sono alla ricerca di qualcosa all’inizio e alla fine della stringa. Il “.*” combinazione è utilizzata sia l’inizio e la fine. Come accennato in precedenza, il punto (.) Metacarattere qualsiasi carattere alfanumerico, e metacarattere * significa “zero o più”. Tra i gruppi sono tra parentesi. Il “? =” Combinazione significa “il prossimo testo deve essere come questo”. Questo costrutto non acquisire il testo. In questo esempio, invece di specificare l’ordine in cui le cose dovrebbero apparire, è dicendo che deve apparire, ma non siamo preoccupati per l’ordine.
Il primo raggruppamento è (?=.*{ 8,}). Questo controlla se ci sono almeno 8 caratteri nella stringa. Il raggruppamento successivo (?=.*[ 0-9]) significa “qualsiasi carattere alfanumerico può succedere zero o più volte, poi ogni cifra può accadere”. Quindi, questo controlla se c’è almeno un numero nella stringa. Ma dal momento che la stringa non viene catturato, una cifra che può apparire ovunque nella stringa. I raggruppamenti prossimo (?=.*[ az]) e (?=.*[ AZ]) sono alla ricerca di lettere minuscole e lettere maiuscole di conseguenza qualunque punto della stringa.
Infine, prenderemo in considerazione le espressioni regolari per validare un indirizzo email:
$ Email = nome.cognome @ aaa.bbb.com;
$ regexp = “/^[^ 0-9] [A-z0-9_ ]+([.][ A-z0-9_ ]+)*[@] [A-z0-9_ ]+([.][ A-z0-9_ ]+)*[.][ Az] {2,4 }$/”; if (preg_match ($ regexp, $ email)) { echo “Indirizzo e-mail è valido.”; } else { echo “L’indirizzo email è non valido.”; } ?>
Questa verifica espressione regolare per il numero all’inizio e controlli anche per periodi più il nome utente e nome di dominio l’indirizzo email. Proviamo a indagare su questa espressione regolare da soli.
Per le ragioni di velocità, il preg_match () funzione corrisponde solo il primo modello che trova in una stringa. Ciò significa che è molto rapido per verificare se un modello esiste in una stringa. Una funzione alternativa, preg_match_all () , corrisponde a un modello contro una stringa tutte le volte che il modello lo permette, e restituisce il numero di volte che ha trovato.
Torna in alto
Modelli sostituzione
Negli esempi precedenti, abbiamo cercato i modelli in una stringa, lasciando intatta la stringa di ricerca. Il preg_replace () funzione cerca sottostringhe corrispondenti a un modello e poi li sostituisce con un nuovo testo. preg_replace () prende tre parametri di base e uno supplementare. Questi parametri sono, in ordine, un’espressione regolare, il testo con cui sostituire un modello trovato, la stringa da modificare e l’ultimo argomento opzionale che specifica quante partite verranno sostituiti.
preg_replace (modello, [limite] sostituzione, soggetto)
La funzione restituisce la stringa modificata se una partita è stato trovato o una copia immutata della stringa originale altrimenti. Nel seguente esempio cerchiamo la frase d’autore e sostituire l’anno con la corrente.
eco preg_replace (“/([ Cc] opyright) 200 (3 | 4 | 5 | 6) / “,” $ 1 2007 “,” Copyright 2005 “);
?>
Nel precedente esempio usiamo indietro riferimenti nella stringa di sostituzione. Indietro riferimenti rendono possibile l’utilizzo di parte di uno schema corrispondente nella stringa di sostituzione. Per utilizzare questa funzione, è necessario utilizzare le parentesi per avvolgere tutti gli elementi della vostra espressione regolare che si potrebbe desiderare di utilizzare. È possibile fare riferimento al testo accompagnato da criterio di riconoscimento parziale con il simbolo del dollaro ($) e il numero della sotto-regola. Per esempio, se si utilizza sottopattern, $ 0 è impostato per tutta la partita, allora $ 1, $ 2 e così via sono impostati per le gare individuali per ogni subpattern.
Nel seguente esempio cambieremo il formato della data da “aaaa-mm-gg” a “gg / mm / yyy”:
eco preg_replace (“/ ( d +) – ( d +) – ( d +)/”,” $ 2 / $ 3 / $ 1 “,” 2007/01/25 “);
>?
Siamo anche in grado di passare un array di stringhe come soggetto per rendere la sostituzione di tutti loro. Per effettuare sostituzioni multiple sulla stessa stringa o un array di stringhe con una chiamata a preg_replace () , si dovrebbe passare array di modelli e sostituzioni. Date un’occhiata a questo esempio:
$ Search = array (“/ ( w {6} s (w {2}) s ( w +) / e”,
“/ ( d {4}) – ( d {2}) – ( d {2}) s ( d {2}: d {2}: d {2 })/”); ‘. “$ 1” strtoupper (“$ 2”)’ $ replace = array (, “$ 3 / $ 2 / $ 1 $ 4”); $ stringa = “Inviato da Giovanni | 2007/02/15 02:43:41”; preg_replace echo ($ ricerca, $ sostituisci, $ stringa);>?
Nel precedente esempio usiamo la funzionalità interessanti – si può dire a PHP che il testo corrisponde dovrebbe essere eseguito come codice PHP dopo la sostituzione ha avuto luogo. Dal momento che abbiamo aggiunto una “e” alla fine dell’espressione regolare, PHP eseguirà la sostituzione fa. Cioè, ci vorrà strtoupper (nome) e sostituirlo con il risultato della strtoupper () funzione, che è NAME.
Torna in alto
Array Processing
PHP preg_split () funzione consente di spezzare una stringa a parte basandosi su qualcosa di più complicato di una sequenza di caratteri letterali. Quando è necessario dividere una stringa con un’espressione dinamica, piuttosto che un uno fisso, questa funzione viene in soccorso. L’idea di base è la stessa preg_match_all () eccetto che, invece di restituire i pezzi abbinati della stringa oggetto, restituisce una serie di pezzi che non corrispondono al modello specificato. L’esempio seguente utilizza un’espressione regolare per dividere la stringa da qualsiasi numero di virgole o spazi:
$ Keywords = preg_split (“/ [ s ,]+/”,” php, le espressioni regolari “);
print_r ($ parole chiave);
?>
Un’altra funzione utile è il PHP preg_grep () funzione che restituisce quegli elementi di un array che corrispondono a un modello dato. Questa funzione attraversa l’array di input, tutti gli elementi di prova contro il modello fornito. Se viene trovata una corrispondenza, l’elemento corrispondente viene restituito come parte della matrice che contiene tutte le partite. Di seguito le ricerche esempio attraverso una serie e tutti i nomi che iniziano con le lettere AJ:
$ Nome = array (‘Andrea’, ‘John’, ‘Pietro’, ‘Nastin’, ‘Bill’);
$ output = preg_grep (‘/^[ am] / i ‘, $ nomi);
print_r ($ output) ;
?>