) Ti ho mostrato un esempio di utilizzo delle espressioni regolari per trovare parti specifiche del codice sorgente di una pagina. Ora impareremo come scriverli noi stessi. Questa abilità ti aiuterà a scrivere, cancellare il testo da frammenti non necessari, cercare le parti necessarie in grandi volumi di testo e così via.
Questo argomento è abbastanza difficile, ma cercherò di evidenziare brevemente i punti più importanti. Non so quanto posso farlo, ma spero che la lezione sia utile.
Quindi, per cominciare, ci sono diverse funzioni per lavorare con le espressioni regolari in PHP, ma tre sono più comunemente usate:
- preg_replace - cerca e sostituisci il testo che corrisponde all'espressione regolare;
- preg_match - solo ricerca regolare;
- preg_split - cerca e divide il testo.
Almeno nelle lezioni precedenti, li abbiamo usati. Piuttosto, al posto di preg_match c'era preg_match_all, ma questa è essenzialmente la stessa cosa, solo che quest'ultimo non interrompe la ricerca dopo il primo ritrovamento. Cioè, se usiamo preg_match, non troveremo tutte le occorrenze, ma solo la prima.
La scelta in quale situazione utilizzare quale funzione è abbastanza semplice. Abbiamo bisogno di sostituire: usiamo la sostituzione, come nel caso in cui avessimo bisogno di rimuovere parti non necessarie del codice della pagina, ricordi?
$ page = preg_replace ("/ ^] / i "," ", $ pagina); $ pagina = preg_replace (" /
Il primo parametro della funzione è una regex, che determina cosa stiamo cercando. Il secondo è ciò che stiamo sostituendo. Terzo - Dove stiamo guardando. Pertanto, qui abbiamo preso la variabile $ page e le abbiamo assegnato il risultato della funzione preg_replace, dove abbiamo cercato tutti i tipi di input = caselle di controllo, nonché le etichette di apertura e chiusura. Li hanno sostituiti con ", cioè li hanno semplicemente cancellati. Spero che qui sia tutto chiaro. Passeremo più avanti all'analisi dell'espressione stessa (primo parametro della funzione).
C'era anche un esempio di utilizzo di preg_match_all, che è stato utile per trovare tutti i collegamenti nel resto del testo. Abbiamo quindi bisogno di collegamenti perché contenevano le parole chiave che abbiamo analizzato. Ecco cosa è successo:
Preg_match_all ("/
Il primo parametro, di nuovo, è il normale, per trovare tutti i collegamenti, che sono naturalmente racchiusi nel tag "a" (se non sei amichevole con il markup html, allora leggilo). La seconda è una variabile che contiene il testo con cui avverrà la ricerca. Il terzo parametro è una variabile, in cui viene inserito il risultato - $ ok. Dopodiché, non resta che passare attraverso tutti gli elementi $ ok necessari per ottenere i keyfish di cui abbiamo bisogno. Separatamente, va detto che in uscita otteniamo un array multidimensionale. Ecco perché lo emettiamo in un modo così complicato: $ ok [$ j]. Per vedere la struttura dell'array, usa la funzione qui sotto e capirai tutto.
Stampa_r ($ ok);
Qui, sembra, abbiamo capito le funzioni che abbiamo usato per il lavoro. Ora non resta che imparare a scrivere queste espressioni molto regolari, che sono il primo parametro di ciascuno di questi metodi. Passiamo alla cosa più importante.
Come scrivere i regolari?
Per prima cosa, diamo un'occhiata alle costruzioni di base. Le espressioni hanno opzioni. Sono specificati da una lettera e scritti alla fine, preceduti da una barra.
Inoltre, sono supportati i seguenti metacaratteri: 
I metacaratteri, a loro volta, possono avere modificatori: 
Bene, ora possiamo passare all'analisi dei nostri habitué dell'ultima lezione. Sulla base delle tavolette di cui sopra, proviamo a capire cosa abbiamo. Ecco l'espressione:
/^] / io
La prima e l'ultima barra "/" indicano che è presente un'espressione regolare al loro interno. Allo stesso tempo, dopo l'ultimo, mettiamo "i", questa è un'opzione, come nella prima tabella - non fa distinzione tra maiuscole e minuscole. All'interno delle barre, la linea regolare stessa. Inizia con un segno meno di e un tag di input, e tutto ciò che viene dopo, fino a un punto, che è un testo semplice da cercare. Ma il punto stesso e i simboli dopo di esso - questo è già più interessante. In questo caso, la costruzione ".*?" indica qualsiasi sequenza di caratteri. Cioè, se combini solo il testo e la costruzione data, selezioneremo tutto il testo dopo la prima occorrenza fino alla fine. Per interrompere, devi soddisfare il tag html di chiusura "maggiore di" o il carattere di nuova riga. Questo design ci offre questa opportunità:
I simboli tra parentesi quadre sono, per così dire, collegati da un OR logico. La fine è un segno di maggiore di OPPURE l'inizio di una riga.
Questa è l'intera espressione, in essa impostiamo la condizione iniziale, intermedia e finale. Non è difficile, vero? Ecco un'illustrazione per chiarezza: 
Analizziamone un'altra per solidificare il tutto. Li abbiamo cercati per i link:
/
Leggiamo l'espressione. Ancora una volta, scarta prima le barre e le opzioni. I flag "uis" sono comprensibili, ad eccezione della "u" che non ho descritto - indica che stiamo usando la codifica Unicode. Non rimane molto. L'inizio è il tag "a", che si apre, poi arriva la classe
il che significa NON più o meno (apertura e chiusura di tag html), ovvero qualsiasi carattere in questo caso. "+?" Viene aggiunto alla classe, il che significa che questa classe sarà presente 1 o più volte (ma almeno 1 volta di sicuro). E poi arriva il tag html di chiusura per il tag "a". C'è del testo all'interno del collegamento, che è impostato dal gruppo
Dopotutto, non sappiamo che tipo di testo ci sarà, quindi definiamo un tale gruppo. E alla fine, il tag di chiusura "a":
Si prega di notare che stiamo eseguendo l'escape della barra con una barra rovesciata in modo che venga percepito come testo normale.
Fuh. L'argomento è davvero abbastanza complesso, ci vuole pratica. Forse sto facendo qualcosa di non proprio ottimale e puoi creare altre espressioni regolari più corrette, ma sono la stessa persona autodidatta come te, quindi non giudicare rigorosamente, ma piuttosto condividi le tue opzioni nei commenti. Inoltre, se qualcosa non è chiaro, i commenti e una pagina di contatto sono al tuo servizio.
Cominciamo con cos'è una regex. Ecco la risposta alla mia domanda, c'è una lettera "e" nella parola "test"? "C'è!" tu dici. Allora ti faccio la seconda domanda, come hai trovato la lettera "e" nella parola "test"? La risposta è ovvia, prendiamo il primo carattere, cioè "t" e lo confrontiamo con quello che stiamo cercando, cioè con "e". Se non sono uguali, prendiamo il secondo carattere, cioè "e", lo confrontiamo con quello che stiamo cercando, cioè "e". Ecco! È stata trovata una corrispondenza. Risposta: La parola "test" contiene la lettera "e".
Ora rispondi a un'altra domanda, dov'è l'espressione regolare in questo esempio? Spero che tu abbia indovinato che l'espressione regolare qui è ciò che stiamo cercando nella parola "test". Cioè, la lettera "e" in questo esempio è un'espressione regolare.
A cosa servono le espressioni regolari in php? Nella mia pratica, sono state utilizzate espressioni regolari, ad esempio, per determinare se un indirizzo e-mail è ben formato. Tali espressioni vengono utilizzate anche per determinare la correttezza del nome utente e della password. Usando le espressioni regolari, puoi trovare l'indirizzo nel link e salvarlo. Molte cose che puoi fare Analizzando questo, puoi identificare la funzione principale delle espressioni regolari e due secondarie. Funzione principale, questa è una ricerca di corrispondenze in una stringa. Gli effetti collaterali sono il salvataggio delle corrispondenze trovate e la loro sostituzione.
Prima espressione regolare
In teoria, capiamo come trovare il simbolo "e" nella parola "test", come viene implementato in pratica? Per utilizzare le espressioni regolari in php, vengono solitamente utilizzate le seguenti funzioni:
preg_match ("espressione regolare (schema)", "variabile in cui viene eseguita la ricerca", "variabile in cui viene salvato il risultato della ricerca (parametro opzionale)"); - Funzione di corrispondenza
preg_replace ("espressione regolare (schema)", "Con cosa sostituire la corrispondenza trovata", "variabile in cui sostituire"); - Funzione di sostituzione
Iniziamo a utilizzare queste funzioni.. Ecco un esempio di ricerca del carattere "e" nella parola "test":
$ a = "prova";
if (preg_match ("/ e /", $ a)) echo "trovato!!";
Il codice descrive la condizione, se viene trovato qualcosa nella variabile $ a dal modello, quindi visualizza il messaggio "trovato!!" Come puoi vedere, il nostro modello è tra due "/". In questo caso, il "/" simboleggia l'inizio e la fine del nostro modello... Spero che questo sia chiaro.
Tutto questo è ovviamente interessante ... ma questo è solo il nostro modello, che è molto semplice, non credi? Dopotutto, raramente abbiamo bisogno di trovare qualche simbolo in una variabile. Nella maggior parte dei casi, dobbiamo trovare molti simboli, inoltre, sconosciuti. Come essere? Poniamoci un problema e cerchiamo di risolverlo. Supponiamo di avere una stringa composta da numeri e una lettera inglese sconosciuta
Come trovi questa lettera? Può esistere qualsiasi lettera dell'alfabeto inglese, come si può definire? Tu stesso hai risposto alla tua domanda, c'è qualche lettera, cioè è nell'intervallo dalla a alla z. Gli intervalli possono essere utilizzati nelle espressioni regolari. Se non sappiamo quale carattere stiamo cercando, ma sappiamo per certo che questo carattere è una lettera dell'alfabeto inglese, il record sarà il seguente:
$a = "123a321";
if (preg_match ("//", $ a)) echo "trovato!!";
Notare che l'intervallo è racchiuso tra parentesi "[" "]". Tutto ciò che è racchiuso in tali parentesi è definito come uno carattere, in questo caso il carattere va dalla a alla z. Se dobbiamo trovare non una lettera, ma un numero, il record sarà così:
$a = "abc1cba";
if (preg_match ("//", $ a)) echo "trovato!!";
Voglio anche notare che le espressioni regolari fanno distinzione tra maiuscole e minuscole, quindi i caratteri "A" e "a" sono completamente diversi, per cercare quelli e quei caratteri, scrivono in questo modo:
$a = "123a321";
if (preg_match ("//", $ a)) echo "trovato!!";
C'è anche una ricerca di lettere russe, viene eseguita allo stesso modo dell'inglese:
$ a = "123ы321";
if (preg_match ("/ [a-za-z] /", $ a)) echo "trovato!!";
metacaratteri
Abbiamo imparato a cercare un carattere sconosciuto in una stringa. E se avessimo bisogno di trovare più simboli? I cosiddetti metacaratteri ci vengono in soccorso... Supponiamo di avere una stringa con numeri, lettere, come descriverla nel template? Puoi farlo:
stringa - 123а321
campione -
Hmm ... il modello corrisponde davvero alla nostra stringa e, quando controllato per la conformità, darà il tanto atteso true! Ma una specie di registrazione ingombrante, non credi?
Ecco come puoi accorciarlo:
stringa - 123а321
campione - *
Mi sembra così più corto Cos'è il simbolo "*"? Questo è il vero metacarattere, significa che il carattere che abbiamo descritto (cioè un carattere che può contenere numeri da 0 a 9 o lettere dell'alfabeto inglese, dalla a alla z) può essere ripetuto all'infinito, o più di una volta. Si si! Questo metacarattere corrisponderà in una variabile vuota, poiché anche l'assenza del simbolo che abbiamo descritto tornerà vero! Ricorda questo
Quali altri metacaratteri ci sono?
Ad esempio il metacarattere "+" È quasi simile al metacarattere "*" con una piccola eccezione. "*" restituirà vero anche se non ci sono caratteri e "+" verificherà la presenza di almeno un carattere. Cioè, se la stringa richiede la presenza minimo carattere singolo quindi utilizzare "+" invece di "*"
Il metacarattere "?" Significa che la stringa non deve contenere più di un carattere richiesto. Permettetemi di darvi un paio di esempi per gli ultimi due metacaratteri che ho descritto.
Supponiamo di dover controllare la correttezza della password dell'utente. Pensiamo a cosa dovrebbe contenere la password dell'utente? Bene, in primo luogo, deve essere almeno un carattere. In secondo luogo, dovrebbe contenere solo numeri e lettere dell'alfabeto inglese, quindi l'espressione regolare sarà simile a questa:
$ a = "qwerty12345";
Quali caratteri abbiamo consentito? Lettere inglesi di qualsiasi registro e numero. Ora prova a lasciare una riga vuota al posto della password.
$ un = "";
if (preg_match ("/ + /", $ a)) echo "La password è corretta";
Non vedrai il messaggio "La password è corretta". Come mai? Perché il metacarattere "+" ha controllato la stringa per la presenza di almeno un carattere.
E ora un piccolo trucco, diamo un'occhiata alla nostra espressione, non abbiamo permesso, diciamo, uno spazio in essa, vero? metti uno spazio alla fine della password ed esegui
$ a = "qwerty12345";
if (preg_match ("/ + /", $ a)) echo "La password è corretta";
E perché vediamo il nostro messaggio sulla password corretta? Abbastanza semplice... funzione preg_match (); interrompe il controllo alla prima corrispondenza. Cioè, il carattere "q" corrisponde allo schema da noi descritto e tutto il resto non è più importante per la funzione.Quindi cosa fare? Ecco come risolverlo:
$ a = "qwerty12345";
if (preg_match ("/ ^ + $ /", $ a)) echo "La password è corretta";
Aggiungendo "^" all'inizio dell'espressione e "$" alla fine, diciamo alla funzione di corrispondere al modello. tutto linea. Se esegui questo codice, non vedrai il messaggio, poiché la fine della password contiene un carattere non valido - uno spazio
Ora cambia il metacarattere "+" in "?" Cosa pensi che succederà? Il messaggio corretto sulla correttezza della password sarà assente, poiché la password contiene più di un carattere. Spero di aver spiegato correttamente come funzionano questi tre metacaratteri comunemente usati.
A volte "non" è meglio
Per lo meno, abbiamo imparato a controllare la correttezza della password, e questo è un bene! Lascia che ti parli di un altro modo per trovare qualcosa in una stringa. Diciamo che dobbiamo verificare l'assenza di numeri in una stringa. Come farlo? Ecco la linea:
(Ho deliberatamente introdotto questi simboli "-_ + ()" in modo che la vita non sembri miele ...) Potremmo comporre la seguente espressione:
Ma devi essere d'accordo, perché non sempre sappiamo quali caratteri sono usati in una stringa, ma sappiamo per certo che non dovrebbero esserci numeri in essa! Pertanto, sarebbe più logico scrivere semplicemente un modello che salti le righe in cui No cifre, e non quelle in cui c'è "Oh mio Dio, quanti simboli incomprensibili!!!"... Ecco un esempio di un'espressione ben formata per tali attività:
$ un = "un -_ + ()";
if (preg_match ("/ ^ [^ 0-9] + $ /", $ a)) echo "Nessun numero!";
Come abbiamo raggiunto questo obiettivo? Abbiamo introdotto un simbolo ma! il maiuscolo "^" ([^ 0-9]) posto all'inizio significa che la riga di questo carattere contiene non dovrebbe Spero che abbiamo capito
Bene, concludiamo un po' ... darò due esempi con spiegazioni, durante i quali impareremo come salvare il risultato della ricerca in una variabile e impareremo come verificare la correttezza dell'indirizzo postale
L'ho visto, l'ho salvato!
Il mio blog
$ un = " Il mio blog";
preg_match ("/ / ", $ a);
Nella nostra espressione regolare, abbiamo descritto tutti i possibili caratteri che possono essere inclusi nel collegamento. Voglio anche attirare l'attenzione sulle virgolette e sui caratteri "/" nella nostra espressione .. Sono preceduti da una barra rovesciata, a cosa serve? Il punto è che "/" e le virgolette sono di per sé caratteri speciali. E affinché il modello li percepisca come simboli ordinari, dobbiamo schermarli. La retinatura viene eseguita aggiungendo una barra rovesciata prima dei caratteri speciali. spero sia chiaro
$ un = " Il mio blog";
preg_match ("/ / ", $ a, $ b);
Bene, e di conseguenza, è necessario aggiungere un parametro aggiuntivo sotto forma della variabile $ b, in cui verrà memorizzato il collegamento trovato. È inoltre necessario sapere che il risultato della ricerca è inserito in un array. Quindi la variabile $ b è un array. Le informazioni che stiamo cercando sono sotto l'indice 1. Ciò significa che il risultato della ricerca è nella variabile $ b. visualizzeremo il risultato sullo schermo:
$ un = " Il mio blog";
preg_match ("/ / ", $ a, $ b);
eco $ b;
L'indirizzo corretto è la chiave del successo!
Bene, al passaggio successivo, la risposta alla domanda, l'e-mail è corretta? Innanzitutto, devi sapere quali caratteri sono consentiti negli indirizzi? Per quanto ne so, i caratteri consentiti includono:
- Lettere inglesi, numeri, "_", "-" emmmm come tutto... Procediamo da questo.
- Successivamente abbiamo "@"
- Dopo, lettere inglesi
- Inoltre, il punto
- E ancora, lettere inglesi...
Quindi l'espressione regolare sarà la seguente:
$ un = " [e-mail protetta]";
if (preg_match ("/ ^ [e-mail protetta]+. + $ / ", $ a)) echo" L'indirizzo e-mail è corretto! ";
else echo "L'indirizzo e-mail NON è corretto!";
Bene ... spero che tali record non ti spaventino ora e tu possa capirli abbastanza.
Sul seguito, voglio dire qualcosa. L'articolo si è rivelato ingombrante e allo stesso tempo ha coperto solo una parte delle possibilità. Se stai leggendo questa frase, molto probabilmente l'hai letta fino alla fine, da cui grazie mille
Per quanto riguarda il ciclo di articoli sullo sviluppo di un blog cms, la prima parte del ciclo Vi annuncio che è chiuso! Nel prossimo futuro inizieremo a implementare il pannello di amministrazione, quindi non "cambiare" Se hai domande, sarò felice di rispondere. Tutto il meglio per te, ho tutto!
Le espressioni regolari sono modelli speciali per trovare una sottostringa nel testo. Con il loro aiuto, puoi risolvere le seguenti attività in una riga: "controlla se la stringa contiene numeri", "trova tutti gli indirizzi e-mail nel testo", "sostituisci diversi punti interrogativi consecutivi con uno".
Cominciamo con una saggezza popolare di programmazione:
Alcune persone, di fronte a un problema, pensano: "Sì, sono intelligente, lo risolverò con le espressioni regolari". Ora hanno due problemi.
Modelli di esempio
Cominciamo con un paio di semplici esempi. La prima espressione nell'immagine seguente cerca una sequenza di 3 lettere, dove la prima lettera è "k", la seconda è una qualsiasi lettera russa e la terza è una "t" senza distinzione tra maiuscole e minuscole (ad esempio, "cat" o "CAT" corrisponde a questo modello). La seconda espressione cerca l'ora nel testo nel formato 12:34.
Qualsiasi espressione inizia con un carattere delimitatore. Il simbolo / viene solitamente usato così com'è, ma puoi anche usare altri simboli che non hanno uno scopo speciale nei modelli regolari, ad esempio ~, # o @. I delimitatori alternativi vengono utilizzati se / può apparire nell'espressione. Quindi viene lo schema della stringa che stiamo cercando, seguito da un secondo delimitatore e alla fine possono esserci una o più lettere di bandiera. Forniscono opzioni aggiuntive durante la ricerca di testo. Ecco alcuni esempi di bandiere:
- i - dice che la ricerca dovrebbe essere senza distinzione tra maiuscole e minuscole (distinta tra maiuscole e minuscole per impostazione predefinita)
- u - dice che l'espressione e il testo cercato utilizzano la codifica utf-8, non solo le lettere latine. Senza di essa, la ricerca di caratteri russi (e di qualsiasi altro non latino) potrebbe non funzionare correttamente, quindi dovresti sempre usarla.
Il modello stesso è costituito da simboli regolari e costrutti speciali. Bene, ad esempio, la lettera "k" nelle linee regolari significa se stessa, ma i simboli significano "in questo luogo può esserci qualsiasi numero da 0 a 5". Ecco un elenco completo di caratteri speciali (sono chiamati metacaratteri nel manuale php) e tutti gli altri caratteri nell'espressione regolare sono normali:
Di seguito analizzeremo il significato di ciascuno di questi simboli (e spiegheremo anche perché la lettera "ё" è resa separatamente nella prima espressione), ma per ora proviamo ad applicare le nostre espressioni regolari al testo e vediamo cosa succede. Php ha una funzione speciale preg_match ($ regexp, $ text, $ match) che accetta un pattern regolare, un testo e un array vuoto come input. Controlla se il testo contiene una sottostringa che corrisponde al modello dato e restituisce 0 in caso contrario o 1 se ce n'è uno. E nell'array passato nell'elemento con indice 0, viene inserita la prima corrispondenza trovata con l'espressione regolare. Scriviamo un semplice programma che applica espressioni regolari a diverse stringhe:
Dopo aver letto l'esempio, esploriamo le espressioni regolari in modo più dettagliato.
Parentesi nelle espressioni regolari
Ribadiamo cosa significano i diversi tipi di parentesi:
- Le parentesi graffe a (1,5) specificano il numero di ripetizioni del carattere precedente - in questo esempio, l'espressione cerca da 1 a 5 lettere consecutive "a"
- Le parentesi quadre significano "uno qualsiasi di questi caratteri", in questo caso le lettere a, b, c, x, y, z o un numero da 0 a 5. Altri caratteri speciali come | o * - rappresentano un carattere normale. Se il simbolo ^ si trova all'inizio delle parentesi quadre, il significato è invertito: "qualsiasi carattere, eccetto quelli specificati" - ad esempio [^ a-c] significa "qualsiasi carattere eccetto a, b o c".
- Le parentesi raggruppano caratteri ed espressioni. Ad esempio, nell'espressione abc + il segno più si riferisce solo alla lettera c e questa espressione cerca parole come abc, abcc, abccc. E se metti le parentesi a (bc) + allora il quantificatore plus si riferisce alla sequenza bc e l'espressione cerca le parole abc, abcbc, abcbcbc
Nota: tra parentesi quadre, puoi specificare intervalli di caratteri, ma ricorda che la lettera russa ё va separatamente dall'alfabeto e per scrivere "qualsiasi lettera russa", devi scrivere [a-yayo].
Bexsles
Se hai guardato altri tutorial sulle espressioni regolari, probabilmente avrai notato che la barra rovesciata è scritta in modo diverso ovunque. Da qualche parte scrivono una barra rovesciata: \ d, ma qui negli esempi viene ripetuta 2 volte: \\ d. Come mai?
Il linguaggio delle espressioni regolari richiede di scrivere la barra rovesciata una volta. Tuttavia, nelle stringhe con virgolette singole e doppie in PHP, il backslash ha anche un significato speciale: il manuale sulle stringhe. Bene, per esempio, se scrivi $ x = "\ $"; quindi PHP interpreterà questa come una combinazione speciale e inserirà solo il carattere $ nella stringa (e il motore regex non saprà della barra rovesciata prima di essa). Per inserire la sequenza \ $ in una stringa, dobbiamo raddoppiare la barra rovesciata e scrivere il codice come $ x = "\\ $"; ...
Per questo motivo, in alcuni casi (dove una sequenza di caratteri ha un significato speciale in PHP) ci viene richiesto di raddoppiare la barra rovesciata:
- Per scrivere \ $ nella regex, scriviamo nel codice "\\ $"
- Per scrivere \\ nell'espressione regolare, raddoppiamo ogni barra rovesciata e scriviamo "\\\\"
- Per scrivere una barra rovesciata e un numero (\1) nella griglia regolare, la barra rovesciata deve essere raddoppiata: "\\ 1"
In altri casi, una o due barre rovesciate daranno lo stesso risultato: "\\ d" e "\ d" inseriranno una coppia di caratteri \ d nella stringa - nel primo caso 2 barre rovesciate sono una sequenza per l'inserimento di una barra rovesciata, nel secondo caso non c'è una sequenza speciale e i caratteri verranno inseriti così come sono. Puoi controllare quali caratteri sono inseriti nella stringa e cosa vede il motore regex con echo: echo "\ $"; ... Sì, è difficile, ma cosa puoi fare?
Costruzioni speciali in regolari
- \ d cerca una cifra qualsiasi, \ D - un carattere qualsiasi tranne una cifra
- \ w corrisponde a qualsiasi singola lettera (qualsiasi alfabeto), cifra o carattere di sottolineatura _. \ W corrisponde a qualsiasi carattere eccetto lettera, numero, trattino basso.
Inoltre, c'è una comoda condizione per indicare un confine di parola: \ b. Questa costruzione significa che su un lato deve esserci un carattere che è una lettera / numero / trattino basso (\ w), e sull'altro lato non lo è. Bene, per esempio, vogliamo trovare la parola "gatto" nel testo. Se scriviamo la regex / cat / ui, troverà la sequenza di queste lettere ovunque, ad esempio all'interno della parola "bestiame". Questo chiaramente non è quello che volevamo. Se aggiungiamo la parola condizione al contorno al quadrato regolare: / \ bcat \ b / ui, ora verrà cercata solo la parola separata "cat".
Manuale
- Sintassi delle espressioni regolari PHP, descrizione dettagliata
Quando lavorano con testi in qualsiasi linguaggio di programmazione moderno, gli sviluppatori devono costantemente affrontare il compito di controllare i dati inseriti per la conformità con il modello desiderato, trovare e sostituire frammenti di test e altre operazioni tipiche per l'elaborazione di informazioni simboliche. Lo sviluppo dei propri algoritmi di verifica comporta una perdita di tempo, incompatibilità del codice del programma e complessità nel suo sviluppo e modernizzazione.
Il rapido sviluppo di Internet e dei linguaggi di sviluppo WEB ha richiesto la creazione di mezzi universali e compatti di elaborazione delle informazioni testuali con la quantità minima di codice richiesta per questo. Il linguaggio PHP, popolare tra i principianti e gli sviluppatori professionisti, non fa eccezione. L'espressione regolare come linguaggio per modelli di testo consente di semplificare le attività di elaborazione testi e di ridurre il codice del programma di decine o centinaia di righe. Molte attività non possono essere risolte senza di essa.
Espressioni regolari in PHP
Il linguaggio PHP contiene tre meccanismi per lavorare con le espressioni regolari: "ereg", "mb_ereg" e "preg". La più comune è l'interfaccia "preg", le cui funzioni forniscono l'accesso alla libreria PCRE regex, originariamente sviluppata per il linguaggio Perl, inclusa in PHP. Le funzioni Preg cercano corrispondenze in una determinata stringa di testo, secondo un determinato modello nel linguaggio delle espressioni regolari.
Nozioni di base sulla sintassi
Nell'ambito di un breve articolo, è impossibile descrivere in dettaglio l'intera sintassi delle espressioni regolari, esiste una letteratura speciale per questo. Ecco solo gli elementi principali per mostrare le ampie possibilità per lo sviluppatore e comprendere gli esempi di codice.
Formalmente è molto difficile da definire, e quindi semplificheremo la descrizione. L'espressione regolare è una stringa di testo. Consiste in un modello delimitato e un modificatore che specifica come gestirlo. È possibile includere varie alternative e ripetizioni nei modelli.
Ad esempio, nell'espressione / \ d (3) - \ d (2) - \ d (2) / m separatore sarà «/» , seguito dal motivo e dal simbolo "M" sarà un modificatore.
Tutta la potenza delle espressioni regolari è codificata utilizzando i metacaratteri. Il metacarattere della lingua principale è una barra rovesciata - "\". Cambia il tipo del carattere successivo in quello opposto (cioè un carattere ordinario diventa un metacarattere e viceversa). Un altro importante metacarattere è la barra "|", che specifica alternative al modello. Altri esempi di metacaratteri:
PHP tratta lo spazio come un carattere significativo separato durante l'elaborazione di espressioni regolari, quindi le espressioni ABCGDE e ABC WHERE sono diverse.
sottomodelli
In PHP, i sottopattern regolari sono racchiusi tra parentesi e talvolta vengono chiamati "sottoespressioni". Svolgono le seguenti funzioni:
Evidenziando le alternative... Ad esempio, il modello calore (alcuni | uccelli |) corrisponde alle parole "Calore", "uccello di fuoco" e "arrosto"... E senza parentesi, sarà solo una stringa vuota, "uccello" e "arrosto".
Un sottopattern "emozionante". Ciò significa che se una sottostringa corrisponde al modello, vengono restituite tutte le corrispondenze. Per chiarezza, facciamo un esempio. Data la seguente regex: il vincitore riceve ((oro | placcato oro) (medaglia | coppa)) - e una stringa per trovare le corrispondenze: "Il vincitore riceve una medaglia d'oro"... Oltre alla frase originale, la ricerca restituirà: "Medaglia d'oro", "Medaglia", "oro".
Operatori di ripetizione (quadrificatori)
Quando si scrivono espressioni regolari, è molto spesso necessario analizzare le ripetizioni di numeri e simboli. Questo non è un problema se non ci sono molte ripetizioni. Ma cosa succede se non conosciamo il loro numero esatto? In questo caso, è necessario utilizzare metacaratteri speciali.
Per descrivere le ripetizioni, vengono utilizzati i quadrifier - metacaratteri per specificare il numero. I quadrifier sono di due tipi:
- generale, racchiuso tra parentesi;
- abbreviato.
Il quantificatore comune specifica il numero minimo e massimo di ripetizioni consentite di un elemento sotto forma di due numeri tra parentesi graffe, ad esempio: x (2.5). Se il numero massimo di ripetizioni è sconosciuto, il secondo argomento viene omesso: x (2,).
I quantificatori abbreviati sono caratteri per le ripetizioni più comuni per evitare un sovraccarico di sintassi non necessario. Vengono comunemente usate tre abbreviazioni:
1. * - zero o più ripetizioni, che equivale a (0,).
2. + - una o più ripetizioni, ad es.).
3.? - zero o una sola ripetizione - (0,1).
Esempi di espressioni regolari
Per chiunque stia imparando le espressioni regolari, gli esempi sono il miglior tutorial. Ne daremo alcuni che mostrano le loro ampie capacità con il minimo sforzo. Tutti i codici di programma sono completamente compatibili con PHP 4.x e versioni successive. Per una completa comprensione della sintassi e dell'utilizzo di tutte le funzionalità del linguaggio, consigliamo il libro di J. Friedl "Regular Expressions", che esamina a fondo la sintassi e fornisce esempi di espressioni regolari non solo in PHP, ma anche per il linguaggi Python, Perl, MySQL, Java, Ruby e C#.
Verifica della correttezza dell'indirizzo e-mail
Compito. C'è una pagina web che chiede al visitatore un indirizzo email. L'espressione regolare deve verificare la validità dell'indirizzo ricevuto prima di inviare i messaggi. La verifica non garantisce che la casella di posta specificata esista realmente e accetti lettere. Ma può eliminare indirizzi deliberatamente errati.
Soluzione. Come con qualsiasi linguaggio di programmazione, in PHP, le espressioni regolari di convalida degli indirizzi e-mail possono essere implementate in molti modi diversi e gli esempi in questo articolo non sono l'ultima e unica opzione. Pertanto, in ogni caso, forniremo un elenco di requisiti che devono essere presi in considerazione durante la programmazione e l'implementazione specifica spetta interamente allo sviluppatore.
Quindi, l'espressione di convalida dell'e-mail dovrebbe verificare le seguenti condizioni:
- La presenza del simbolo @ nella stringa originale e l'assenza di spazi.
- La parte di dominio dell'indirizzo, seguita dal simbolo @, contiene solo caratteri validi per i nomi di dominio. Lo stesso vale per il nome utente.
- Quando si convalida un nome utente, è necessario determinare la presenza di caratteri speciali come un apostrofo o.Tali caratteri sono potenzialmente pericolosi e possono essere contenuti in attacchi come SQL injection. Evita tali indirizzi.
- I nomi utente accettano solo un punto, che non può essere il primo o l'ultimo carattere in una riga.
- Il nome di dominio deve contenere almeno due e non più di sei caratteri.
Un esempio che tiene conto di tutte queste condizioni può essere visto nella figura sottostante.
Convalida degli URL
Compito. Verifica se la stringa di testo fornita è valida. Nota ancora che le espressioni regolari di convalida dell'URL possono essere implementate in diversi modi.
Soluzione. La nostra versione finale è simile a questa:
/^(https?:\/\/)?((\da-z\.->+)\.((2,6))((\/\w \ .-] *) * \ /? $ /
Ora analizziamo i suoi componenti in modo più dettagliato usando l'immagine.
Controllo dei numeri di carta di credito
Compito.È necessario verificare la correttezza del numero di carta di plastica inserito dei sistemi di pagamento più comuni. Opzione considerata solo per le carte
Soluzione. Quando si crea un'espressione, è necessario tenere conto dell'eventuale presenza di spazi nel numero inserito. I numeri sulla carta sono divisi in gruppi per una facile lettura e dettatura. Pertanto, è naturale che una persona tenti di inserire un numero in questo modo (ad esempio utilizzando gli spazi).
Scrivere un'espressione generica che tenga conto di possibili spazi e trattini è più difficile che scartare semplicemente tutti i caratteri tranne i numeri. Pertanto, si consiglia di utilizzare il metacarattere / D nell'espressione, che rimuove tutti i caratteri tranne i numeri.
Ora puoi andare direttamente alla verifica del numero. Tutte le società di carte di credito utilizzano un formato numerico univoco. L'esempio utilizza questo e il cliente non ha bisogno di inserire il nome dell'azienda - è identificato da un numero. Le carte Visa iniziano sempre con 4 e sono lunghe 13 o 16 cifre. MasterCard inizia nell'intervallo 51-55 con una lunghezza numerica di 16. Di conseguenza, otteniamo la seguente espressione:
Prima di elaborare l'ordine, puoi anche controllare l'ultima cifra del numero, che viene calcolata utilizzando l'algoritmo Luna.
Controllo dei numeri di telefono
Compito. Verifica della correttezza del numero di telefono inserito.
Soluzione. Il numero di cifre nei numeri di rete fissa e mobile varia notevolmente da paese a paese, quindi è impossibile controllare universalmente un numero di telefono utilizzando espressioni regolari per verificarne la correttezza. Ma i numeri internazionali hanno un formato rigoroso e sono ottimi per il controllo dei modelli. Inoltre, sempre più operatori telefonici nazionali stanno cercando di rispettare un unico standard. La struttura del problema è la seguente:
+ CCC.NNNNNNNNNNxEEEE, dove:
C è un prefisso internazionale di 1-3 cifre.
N - numero fino a 14 cifre.
E è un'estensione facoltativa.
Il plus è obbligatorio e la x è presente solo quando è richiesta un'estensione.
Di conseguenza, abbiamo la seguente espressione:
^ \ + (1,3) \. (4,14) (?: x. +)? $
Numeri nell'intervallo
Compito.È necessario assicurarsi che un numero intero di un intervallo specificato corrisponda. Inoltre, è necessario che le espressioni regolari trovino solo numeri da un intervallo di valori.
Soluzione. Ecco alcune espressioni per alcuni dei casi più comuni:
Trovare un indirizzo IP
Compito.È necessario determinare se la stringa specificata è un indirizzo IP IPv4 valido nell'intervallo 000.000.000.000-255.255.255.255.
Soluzione. Come con qualsiasi attività in PHP, un'espressione regolare ha molte varianti. Ad esempio, qualcosa del genere:
Controllo online delle espressioni
Il controllo della correttezza delle espressioni regolari può essere difficile per i programmatori alle prime armi a causa della complessità della sintassi, che differisce dai linguaggi di programmazione "normali". Per risolvere questo problema, esistono molti tester di espressione online che consentono di verificare facilmente la correttezza del modello creato su testo reale. Il programmatore inserisce un'espressione ei dati per la verifica e vede immediatamente il risultato dell'elaborazione. Solitamente è presente anche una sezione di riferimento, che descrive in dettaglio espressioni regolari, esempi e differenze di implementazione per i linguaggi di programmazione più comuni.
Ma non è consigliabile fidarsi completamente dei risultati dei servizi online per tutti gli sviluppatori che utilizzano PHP. Una regex, scritta e testata personalmente, è aggiornata e garantita priva di errori.
Le espressioni regolari sono uno strumento di elaborazione delle stringhe molto potente, ma allo stesso tempo difficile da capire. Descriverò i punti principali. Un'espressione regolare è un modello di stringa. Usando questo modello, puoi cercare occorrenze, effettuare sostituzioni, verificare la corrispondenza del modello.
Regole di composizione del modello
I confini del modello dovrebbero essere indicati da alcuni simboli, spesso usare " / "ma preferisco usare" # "perché l'abbondanza di barre in avanti / indietro può far sembrare orribile i tuoi occhi e" reticoli "di solito non vengono utilizzati da nessun'altra parte. Quindi:" #RegularExpressionBody #"
All'interno dell'espressione regolare, vengono utilizzate le parentesi: si tratta di sottoespressioni che possono essere manipolate, ad esempio:
# ^ / catalogo / (+) / (+) \. html. * #
Questa espressione serve per ottenere i parametri in una stringa URL... All'inizio della riga c'è un carattere speciale " ^ "- questo significa l'inizio di una riga. Il prossimo viene" / Catalogare /"- non ci sono caratteri speciali, questo è solo testo che dovrebbe essere contenuto nella stringa. Quindi hanno incontrato le parentesi, cioè hanno raggiunto la prima sottoespressione. Le parentesi quadre indicano l'insieme di caratteri che possono essere nella stringa in questo punto . Cartello" - "significa enumerazione. Segno" \ "escape caratteri speciali. Quindi, nella prima sottoespressione, possiamo avere lettere GRANDI e minuscole dell'alfabeto latino, numeri da 0 a 9, trattino basso, trattino e punto. Il trattino e il punto sono caratteri speciali, ma qui sono sfuggiti, quindi qui sono solo simboli. Dopo le parentesi quadre c'è un " + "- questo significa che il carattere precedente (e abbiamo questo set di caratteri tra parentesi quadre) può andare 1 o più volte. Poi arriva" / "è solo un personaggio, e una seconda sottoespressione simile. Poi arriva" \ .html"che significa testo" .html". E poi caratteri speciali" .* "punto indica qualsiasi carattere e un asterisco indica qualsiasi importo del carattere precedente. Cioè, dopo" .html"tutto può andare.
Indicazione di quantità, quantificatori
Sopra, abbiamo già considerato tali caratteri che indicano il numero di caratteri precedenti, come ad esempio + e * ... Ecco tutte le possibilità per specificare la quantità:
Personaggi speciali
Esistono abbreviazioni speciali per alcuni gruppi di caratteri:
"Avidità"
Diamo un'occhiata alla nozione di regex avidità. Ad esempio, c'è una riga:
#(
Leggiamo: sottoespressione:
Se tutto è corretto, la sottoespressione corrisponde a:
Ma si adatta anche a:
Lo avremo, perché le espressioni regolari sono greedy per impostazione predefinita. Puoi rimuovere l'avidità usando il modificatore " tu", come questo:
#(
Modificatori
L'espressione regolare può essere seguita da modificatori: " #ThereRegularExpressionBody #ThatModifiers"Tipi di modificatori:
| io | Attiva la modalità senza distinzione tra maiuscole e minuscole, ad es. le lettere maiuscole e minuscole non differiscono nell'espressione. |
| m | Indica che il testo cercato deve essere trattato come più righe. Per impostazione predefinita, il motore delle espressioni regolari tratta il testo come una singola stringa, indipendentemente da cosa sia realmente. Di conseguenza, i metacaratteri "^" e "$" indicare l'inizio e la fine dell'intero testo. Se viene specificato questo modificatore, punteranno rispettivamente all'inizio e alla fine di ogni riga di testo. |
| S | Il metacarattere predefinito " . "non include un carattere di avanzamento riga nella sua definizione. Specificando questo modificatore si rimuove questa restrizione. |
| tu | Rimuove l'avidità della regex |
| tu | Consente alle espressioni regolari di lavorare con Cirillico in UTF-8, altrimenti non funziona correttamente. |
Funzioni php per lavorare con le espressioni regolari
preg_replace
Trova e sostituisci:
Preg_replace (modello $ misto, sostituzione $ mista, soggetto $ misto [, int $ limite = -1 [, int & $ conteggio]]);
Ogni valore può essere una stringa o un array, nel caso $ soggetto array - viene restituito un array, altrimenti una stringa
preg_split
Divide una stringa per espressione regolare:
Preg_split (string $ pattern, string $ soggetto [, int $ limite = -1 [, int $ flag = 0]]);
Restituisce un array di sottostringhe della stringa data materia che è scomposto lungo i confini che corrispondono al modello modello.
