PHP regexp è un potente algoritmo di corrispondenza dei modelli che può essere eseguito in una singola espressione. Le espressioni regolari PHP utilizzano operatori aritmetici (come +, -, ^) per creare espressioni complesse.
A cosa servono le espressioni regolari:
- Le espressioni regolari semplificano l'identificazione dei dati di stringa chiamando una singola funzione. Ciò consente di risparmiare tempo durante la scrittura del codice;
- Durante la convalida dei dati immessi dall'utente come indirizzo e-mail, dominio del sito Web, numero di telefono, indirizzo IP;
- Evidenziare le parole chiave nei risultati di ricerca;
- Le espressioni regolari possono essere utilizzate per identificare i tag e sostituirli.
Espressioni regolari in PHP
PHP contiene funzioni integrate che ti consentono di lavorare con le espressioni regolari. Ora diamo un'occhiata alle funzioni delle espressioni regolari PHP comunemente utilizzate.
- preg_match - Utilizzato per eseguire la corrispondenza del modello di stringa. Restituisce vero se viene trovata una corrispondenza e falso se non viene trovata alcuna corrispondenza;
- preg_split - utilizzato per dividere una stringa secondo uno schema, il risultato viene restituito come array numerico;
- preg_replace – utilizzato per cercare un modello e sostituirlo con una stringa specificata.
Di seguito è riportata la sintassi delle funzioni delle espressioni regolari come preg_match, preg_split o PHP regexp replace:
"nome_funzione" è preg_match, preg_split o preg_replace.
“/…/” - le barre indicano l'inizio e la fine di un'espressione regolare.
“‘/pattern/"” è il pattern che dobbiamo far corrispondere.
"oggetto" è la stringa con cui confrontare il modello.
Vediamo ora degli esempi pratici di utilizzo delle funzioni sopra menzionate.
Preg_match
Il primo esempio utilizza la funzione preg_match per eseguire un semplice pattern match per la parola guru in un dato URL.
Il codice seguente mostra un'implementazione di questo esempio:
Diamo un'occhiata alla parte del codice responsabile dell'output "preg_match('/guru/', $mio_url)".
“preg_match(…)” è la funzione regexp di corrispondenza PHP.
“‘/Guru/"” è un modello di espressione regolare.
"$My_url" è una variabile contenente il testo con cui confrontare il modello.
Preg_split
Diamo un'occhiata a un altro esempio che utilizza la funzione preg_split.
Prenderemo una frase e la divideremo in un array; il modello è progettato per corrispondere a un singolo spazio:
Preg_sostituisci
Considera la funzione preg_replace, che esegue un pattern match e sostituisce il risultato corrispondente con un'altra stringa.
Il codice seguente cerca la parola guru in una stringa. Lo sostituisce con il codice CSS che imposta il colore di sfondo:
Guru", $testo); echo $testo; ?>
Metacaratteri
Gli esempi precedenti utilizzavano modelli semplici. I metacaratteri consentono una corrispondenza di pattern regexp PHP più complessa, come la convalida dell'indirizzo e-mail. Diamo un'occhiata ai metacaratteri comunemente usati.
| Metacarattere | Descrizione | Esempio |
| . | Corrisponde a qualsiasi singolo carattere diverso da un carattere di nuova riga. | /./ - tutto ciò che contiene un carattere. |
| ^ | Contrassegna l'inizio di una riga, escluso il carattere /. | /^PH/ è qualsiasi stringa che inizia con PH. |
| $ | Indica un motivo alla fine di una linea. | /com$/ - guru99.com, yahoo.com, ecc. |
| * | Indica un numero qualsiasi di caratteri, zero o più. | /com*/ - computer, comunicazione, ecc. |
| + | Richiede che i caratteri appaiano prima del metacarattere almeno una volta. | /yah+oo/ - yahoo. |
| Simbolo di fuga. | /yahoo+.com/ - prende il punto con un significato letterale. | |
| […] | Classe di caratteri. | // - abc. |
| az | Indica le lettere minuscole. | /a-z/ - bello, felice, ecc. |
| A-Z | Indica le lettere maiuscole. | /A-Z/ - COSA, COME, PERCHÉ, ecc. |
| 0-9 | Rappresenta qualsiasi numero da 0 a 9. | /0-4/ — 0,1,2,3,4. |
Ora diamo un'occhiata a un complesso esempio di regexp PHP che verifica la validità di un indirizzo email:
Risultato: indirizzo email [e-mail protetta]è valido.
Spiegazione del pattern “+@+.(2.5)$/] “
“‘/…/"” inizia e termina l’espressione regolare.
"^" corrisponde a qualsiasi lettera maiuscola o minuscola, numeri da 0 a 9 e punti, trattini bassi o trattini.
"+@" corrisponde al simbolo @ seguito da lettere minuscole o maiuscole, numeri da 0 a 9 o trattini.
"+.(2,5)$/" specifica un punto utilizzando una barra rovesciata, seguita da eventuali lettere minuscole o maiuscole, il numero di caratteri alla fine della riga deve essere compreso tra 2 e 5.
Le espressioni regolari sono uno strumento molto utile per gli sviluppatori. Le espressioni regolari ti consentono di controllare, cercare e modificare la correttezza del testo.
Questo articolo contiene alcune espressioni molto utili con cui spesso devi lavorare.
Introduzione alle espressioni regolari
Quando vengono introdotte per la prima volta alle espressioni regolari, possono sembrare difficili da comprendere e utilizzare. In realtà, tutto è più semplice di quanto sembri. Prima di considerare esempi complessi, diamo un'occhiata alle nozioni di base:
Funzioni per lavorare con le espressioni regolari in PHP
Verifica del dominio
Verifica del nome di dominio corretto.
$url = "http://esempio.com/"; if (preg_match("/^(http|https|ftp)://(*(?:.*)+):?(d+)?/?/i", $url)) ( echo "Ok."; ) else ( echo "URL sbagliato."; )
Evidenziare le parole nel testo
Un'espressione regolare molto utile per . Utile per la ricerca.
$text = "Frase di esempio, regex è diventata popolare nella programmazione web. Ora impariamo regex. Secondo Wikipedia, le espressioni regolari (abbreviate come regex o regexp, con le forme plurali regex, regexp o regexen) sono scritte in un linguaggio formale che può essere interpretato da un processore di espressioni regolari"; $testo = preg_replace("/b(regex)b/i", " 1", $testo); echo $testo;
Risultati della ricerca evidenziati in WordPress
Come già accennato, l'esempio precedente è molto utile per i file . Applichiamolo a WordPress. Apri il file ricerca.php, trova la funzione il_titolo(). Sostituirlo con quanto segue:
Echo $titolo;
Ora, prima di questa riga, inserisci il codice:
\0", $titolo); ?>
Apri il file style.css. Aggiungi la riga:
Estratto.search-strong ( sfondo: giallo; )
Ottieni tutte le immagini da un documento HTML
Se mai avessi bisogno di trovare tutte le immagini in una pagina HTML, il seguente codice ti tornerà utile. Con esso, puoi facilmente creare un caricatore di immagini utilizzando .
$immagini = array(); preg_match_all("/(img|src)=("|")[^"">]+/i", $dati, $media); non impostato($dati); $data=preg_replace("/(img|src)("|"|="|=")(.*)/i","$3",$media); foreach($data as $url) ( $info = pathinfo($url); if (isset($info["extension"])) ( if (($info["extension"] == "jpg") || ($info["estensione"] == "jpeg") || ($info["estensione"] == "gif") || ($info["estensione"] == "png")) array_push($ immagini, $url);
Rimozione di parole duplicate (indipendentemente dalle maiuscole e minuscole)
$testo = preg_replace("/s(w+s)1/i", "$1", $testo);Rimozione dei segni di punteggiatura duplicati
Simile al precedente, ma rimuove i segni di punteggiatura.
$testo = preg_replace("/.+/i", ".", $testo);
Trovare un tag XML/HTML
Una semplice funzione che accetta due argomenti: il tag da trovare e una stringa contenente XML o HTML.
Funzione get_tag($tag, $xml) ( $tag = preg_quote($tag); preg_match_all("(<".$tag."[^>]*>(.*?).")", $xml, $matches, PREG_PATTERN_ORDER);
Trovare un tag XML/HTML con un valore di attributo specifico
La funzione è simile alla precedente, ma diventa possibile specificare un attributo tag. Per esempio: Funzione get_tag($attr, $valore, $xml, $tag=null) ( if(is_null($tag)) $tag = "\w+"; else $tag = preg_quote($tag); $attr = preg_quote($ attr); $valore = preg_quote($valore); $tag_regex = "/<(".$tag.")[^>]*$attr\s*=\s*". "(["\"])$valore\\2[^>]*>(.*?)<\/\\1>/" preg_match_all($tag_regex, $xml, $matches, PREG_PATTERN_ORDER); return $matches; ) La funzione consente di trovare o verificare la correttezza dei codici colore esadecimali. $stringa = "#555555"; if (preg_match("/^#(?:(?:(3))(1,2))$/i", $string)) ( echo "esempio 6 riuscito."; ) Questo codice troverà e visualizzerà il testo tra i tag $fp = fopen("http://www.catswhocode.com/blog","r"); while (!feof($fp))( $page .= fgets($fp, 4096); ) $titre = eregi(" Molti siti Web vengono eseguiti sul server Web Apache. Se il tuo sito funziona anche su un server taco, potrebbero essere utili le seguenti routine regolari. //Log: server web Apache // Accessi riusciti ai file html. Utile per contare le impressioni sulla pagina. "^((?#IP client o nome dominio)S+)s+((?#autenticazione di base)S+s+S+)s+[((?#data e ora)[^]]+)]s+"(?: GET|POST|HEAD) ((?#file)/[^ ?]+?.html?)??((?#parametri)[^ ?]+)? HTTP/+"s+(?#codice stato)200s+((?#byte trasferiti)[-0-9]+)s+"((?#referrer)[^"]*)"s+"((?#user agent )[^"]*)"$" //Log: server web Apache //errori 404 "^((?#IP client o nome dominio)S+)s+((?#autenticazione di base)S+s+S+)s+ [((?#data e ora)[^]]+)]s+"(?:GET|POST|HEAD) ((?#file)[^ ?]+)??((?#parametri)[^ ? "]+)? HTTP/+"s+(?#codice stato)404s+((?#byte trasferiti)[-0-9]+)s+"((?#referrer)[^"]*)"s+"((?#user agent )[^"]*)"$") Questa espressione regolare controlla una stringa punto per punto: la stringa deve contenere almeno 6 lettere, numeri, trattini bassi e trattini. La riga deve contenere almeno una lettera maiuscola, una lettera minuscola e un numero. "A(?=[-_a-zA-Z0-9]*?)(?=[-_a-zA-Z0-9]*?)(?=[-_a-zA-Z0-9]*?) [-_a-zA-Z0-9](6,)z" Se usi WordPress, potresti trovare utile avere una funzionalità che otterrà tutte le immagini da un post e le visualizzerà. Per utilizzare questo codice, copialo nei file del tema.
post_contenuto; $szSearchPattern = "~ Questa funzionalità è disponibile anche in WordPress e ti consente di sostituire automaticamente le emoticon di testo con immagini. $texte="Un testo con una faccina:-)"; echo str_replace(":-)"," ) Ti ho mostrato un esempio di utilizzo delle espressioni regolari per trovare parti specifiche del codice sorgente di una pagina. Ora impareremo come scriverli da soli. Questa abilità ti aiuterà a scrivere, a cancellare il testo da frammenti non necessari, a cercare le parti necessarie in grandi volumi di testo e così via. Almeno, nelle lezioni precedenti li abbiamo usati. Più precisamente al posto di preg_match c'era preg_match_all, ma sostanzialmente è la stessa cosa, solo che quest'ultimo non interrompe la ricerca dopo il primo risultato. Cioè, se usiamo preg_match, non troveremo tutte le occorrenze, ma solo la prima. Scegliere quale funzione utilizzare in quale situazione è abbastanza semplice. Dobbiamo sostituire: usiamo sostituisci, come nel caso in cui avessimo bisogno di rimuovere parti non necessarie del codice della pagina, ricordi? $pagina = preg_replace("/ ^]/i", "", $pagina); $pagina = preg_replace("/ Il primo parametro della funzione è un carattere regolare che determina cosa stiamo cercando. Il secondo è ciò con cui lo sostituiamo. Terzo: dove stiamo guardando? Pertanto, qui abbiamo preso la variabile $page e le abbiamo assegnato il risultato della funzione preg_replace in cui abbiamo cercato tutti gli input type=checkbox, nonché le etichette di apertura e chiusura. Li hanno sostituiti con ", cioè li hanno semplicemente cancellati. Spero che qui sia tutto chiaro. Passeremo all'analisi dell'espressione stessa (il primo parametro della funzione) un po' più tardi. Preg_match_all("/ Il primo parametro è ancora una volta un'espressione regolare per trovare tutti i collegamenti che sono naturalmente racchiusi nel tag “a” (se non hai familiarità con il markup html, leggi). La seconda è una variabile che contiene il testo che verrà cercato. Il terzo parametro è una variabile in cui viene inserito il risultato: $ok. Dopodiché, non resta che esaminare tutti gli elementi necessari di $ok per ottenere le chiavi di cui abbiamo bisogno. Separatamente, va detto che in uscita otteniamo un array multidimensionale. Ecco perché l'abbiamo visualizzato in modo così complesso: $ok[$j]. Per visualizzare la struttura dell'array, usa la funzione qui sotto e capirai tutto. Stampa_r($ok); Sembra che abbiamo risolto le funzioni che abbiamo utilizzato per il nostro lavoro. Ora non resta che imparare a scrivere queste stesse espressioni regolari, che sono il primo parametro di ciascuno di questi metodi. Passiamo alla cosa più importante. Per prima cosa, diamo un'occhiata alle strutture 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 La prima e l'ultima barra "/" indicano che al loro interno è presente un'espressione regolare. Allo stesso tempo, dopo l'ultimo mettiamo "i", questa è un'opzione, come nella prima tabella - non prendere in considerazione il caso. All'interno delle barre c'è la sequenza regolare stessa. Inizia con il segno meno di e il tag di input, e tutto ciò che viene dopo fino al segno del punto è solo testo semplice da cercare. Ma il punto stesso e i simboli che lo seguono sono più interessanti. In questo caso, la costruzione “.*?” indica qualsiasi sequenza di caratteri. Cioè, se combiniamo solo il testo e questa costruzione, selezioneremo tutto il testo dopo la prima occorrenza e fino alla fine. Per fermarti, devi incontrare un tag HTML di chiusura "più di" o un carattere di nuova riga. Questo design ci offre proprio questa opportunità: I caratteri tra parentesi quadre sono collegati da un OR logico. La fine è il segno maggiore di OPPURE l'inizio della riga. Diamo un'occhiata a un'altra cosa per consolidare il tutto. Abbiamo cercato collegamenti con loro:
/ Leggiamo l'espressione. Ancora una volta, scartiamo prima le barre e le opzioni. I flag "uis" sono autoesplicativi, ad eccezione di "u", che non ho descritto: mostra che stiamo utilizzando la codifica Unicode. Non è rimasto molto. L'inizio è il tag "a", che si apre, poi arriva la classe che significa NON maggiore o minore di (apertura e chiusura dei 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”. All'interno del collegamento è presente del testo specificato dal gruppo Dopotutto, non sappiamo che tipo di testo ci sarà, quindi definiamo un gruppo del genere. E alla fine c'è un tag di chiusura “a”: Tieni presente che eliminiamo la barra utilizzando una barra rovesciata in modo che venga percepita come testo semplice. Uff. L'argomento è davvero piuttosto complesso, richiede pratica. Forse sto facendo qualcosa che non è del tutto ottimale ed è possibile creare altre espressioni regolari più corrette, ma sono autodidatta come te, quindi non giudicare rigorosamente, ma piuttosto condividi le tue opzioni nei commenti. Inoltre, se qualcosa non ti è chiaro, la pagina dei commenti e dei contatti è al tuo servizio. Espressioni regolari (abbreviato come regex) sono sequenze di caratteri che formano modelli di ricerca. Vengono utilizzati principalmente nei modelli di corrispondenza delle stringhe. Breve storia PHP include tre funzioni principali per lavorare con PCRE: preg_match, preg_match_all e preg_replace. Confronto di conformità L'espressione restituisce 1 se viene stabilita una corrispondenza, 0 in caso contrario e false se si verifica un errore: int preg_match (string $modello, string $oggetto [, array &$matches [, int $flags = 0 [, int $offset = 0]]]) Un esempio di espressione regolare che restituisce il numero di corrispondenze trovate: int preg_match_all (string $modello, string $oggetto [, array &$matches [, int $flags = PREG_PATTERN_ORDER [, int $offset = 0]]]) Sostituzione L'espressione restituisce la stringa o l'array sostituito ( basato su $oggetto): preg_replace misto ($modello misto, $sostituzione mista, $oggetto misto [, int $limit = -1 [, int $count]]) Le espressioni regolari in JavaScript sembrano quasi le stesse di PHP. Confronto di conformità Restituisce un array di corrispondenze o null se non viene trovata alcuna corrispondenza: string.match(RegExp); Sostituzione Un'espressione regolare che restituisce una stringa con le sostituzioni effettuate: string.replace(RegExp, sostituzione); Diamo un'occhiata a un esempio in cui dobbiamo trovare indirizzi email in una codebase. Il nostro obiettivo: Prese analogiche Le espressioni regolari sono costituite da due tipi di caratteri: Pensa alle stringhe di input come a bulloni e al modello come a un insieme di connettori per esse (nell'ordine appropriato). Caratteri speciali Quando testi le espressioni regolari, devi sapere come funzionano i caratteri speciali: Corrisponde a tutti i caratteri tranne i ritorni a capo. Se vuoi verificare la conformità con un punto, e solo un punto - , la conformità con lettere, numeri e trattini bassi - w Abbina i caratteri tra parentesi. Supporta intervalli. Alcuni esempi: Un asterisco indica 0 o più caratteri. Abbina 1 o più personaggi. Parentesi graffe (). Valori minimi e massimi. Alcuni esempi di sintassi delle espressioni regolari: Aggiungiamo tutto questo per ottenere un'espressione regolare per gli indirizzi email: /+@+(.+)*/i preg_match_all("/+@+(.+)*/i", $input_lines, $output_array); La sfida: garantire che i dati di input siano quelli previsti. Obiettivo 1: /[^w$.]/ Obiettivo 2: /^(1,2)$/ Le espressioni regolari vanno bene per trovare elementi, ma devi sapere esattamente cosa stai cercando. Molti casi vengono gestiti meglio utilizzando la funzione PHP filter_var. Ad esempio, la convalida dell'indirizzo email dovrebbe essere eseguita utilizzando i filtri integrati di PHP: filter_var(" [e-mail protetta]", FILTER_VALIDATE_EMAIL) Le espressioni regolari alla fine di una riga utilizzano le ancore: ^ - indica l'inizio di una riga. if (!preg_match("%^(1,2)$%", $_POST["subscription_frequency"])) ( $isError = true; ) [^abc] - tutto tranne a, b o c, compresi i ritorni a capo. Un esempio che consente di inserire solo caratteri alfanumerici, trattini, punti e trattini bassi: if (preg_match("/[^0-9a-z-_.]/i", $productCode)) ( $isError = true; ) Le funzioni PCRE più comuni per eseguire la ricerca e la sostituzione sono preg_replace() e preg_replace_callback() . Ma ci sono anche preg_filter() e preg_replace_callback_array() che fanno quasi la stessa cosa. Tieni presente che la funzione preg_replace_callback_array() è disponibile a partire da PHP7. $oggetto = "Voglio mangiare delle mele."; echo preg_replace("/mela|banana|arancia/", "frutta", $oggetto); Risultato Voglio mangiare un po' di frutta. Se un'espressione regolare ha sottomodelli ( tra parentesi), puoi sostituire $N o N (dove N è un numero intero >= 1), questo è chiamato "backlink". $oggetto = "7/11"; echo preg_replace("/(d+)/(d+)/", "$2/$1", $oggetto); Risultato $oggetto = "2001-09-11"; echo preg_replace("/(d+)-(d+)-(d+)/", "$3/$2/$1", $oggetto); Risultato $subject = "Visita https://php.earth/doc per ulteriori articoli."; echo preg_replace("#(https?://([^s./]+(?:.[^s./]+)*[^s]*))#i", "$2", $oggetto) ; Risultato Per ulteriori articoli, visitare php.earth/doc. A volte è necessario eseguire operazioni di ricerca e sostituzione complesse, ad esempio quando si filtra/controlla prima di sostituire. Preg_replace_callback() può tornare utile in questa situazione. L'uso più comune delle espressioni regolari in Perl è negli operatori di ricerca e sostituzione come S//, M/, operatori connettivi =~
O !=
ecc. Di norma, tutti questi operatori hanno opzioni simili come: In genere tutte queste opzioni sono indicate come "/x". Possono anche essere utilizzati all'interno di modelli utilizzando la nuova costruzione (?...) Le espressioni regolari o i modelli sono gli stessi delle procedure regexp in Unix. Le espressioni e la sintassi sono prese in prestito dalle procedure V8 distribuite gratuitamente da Henry Spencer, dove sono descritte in dettaglio. I modelli utilizzano i seguenti metacaratteri (caratteri che denotano gruppi di altri caratteri) spesso chiamati standard egrep: I metacaratteri hanno dei modificatori (scritti dopo il metacarattere): In tutti gli altri casi, le parentesi graffe sono considerate caratteri ordinari (regolari). Quindi "*" è equivalente a (0,) , "+" è (1,) e "?" - (0,1). n e m non possono essere maggiori di 65536. Per impostazione predefinita, i metacaratteri sono avidi. La corrispondenza viene propagata quante più volte possibile, senza considerare l'effetto dei metacaratteri successivi. Se vuoi "ridurre il loro appetito", usa il simbolo "?". Ciò non cambia il significato dei metacaratteri, ne riduce solo la propagazione. Così: I caratteri jolly funzionano allo stesso modo delle virgolette doppie, quindi puoi utilizzare i caratteri `\` - (caratteri barra rovesciata): Inoltre, sono stati aggiunti a Perl i seguenti metacaratteri: Nota che questo è tutto "un" carattere. Utilizza i modificatori per indicare la sequenza. COSÌ: Inoltre, ci sono metacaratteri immaginari. Indica simboli inesistenti nel punto in cui il valore cambia. Ad esempio: Il confine di una parola (\b) è un punto immaginario tra i caratteri \w e \W. All'interno di una classe di caratteri, "\b" rappresenta il carattere backspace. Metacaratteri \UN E \Z- sono simili a "^" e "$", ma se l'inizio della riga "^" e la fine della riga "$" agiscono per ogni riga in una stringa su più righe, allora \UN E \Z indicare l'inizio e la fine di un'intera stringa multilinea. Se all'interno del modello viene utilizzato il raggruppamento (parentesi), il numero della sottostringa del gruppo viene designato come "\digit". Tieni presente che seguendo uno schema all'interno di un'espressione o di un blocco, questi gruppi sono indicati come "$cifra". Inoltre, ci sono ulteriori variabili: Esempio: $s = "Uno 1 due 2 e tre 3"; if ($s =~ /(\d+)\D+(\d+)/) ( print "$1\n"; # Risultato "1" print "$2\n"; # "2" print "$+\n" ; # "2" print "$&\n"; # "1 due 2" print "$`\n" # "Uno " print "$"\n"; # " e tre 3"; Esempio: Perl versione 5 contiene costrutti di template aggiuntivi: $s = "1+2-3*4"; if ($s =~ /(\d)(?=-)/) # Trova il numero seguito da "-" ( print "$1\n"; # Risultato "2" ) else ( print "errore di ricerca\n" ) Esempio: (?!modello) - "guardare" avanti per negazione: $s = "1+2-3*4"; if ($s =~ /(\d)(?!\+)/) # Trova una cifra che non sia seguita da "+" ( print "$1\n"; # Risultato "2") else ( print "cerca errore\ n"; ) (?ismx) - modificatori “interni”. È comodo da utilizzare nei modelli, dove, ad esempio, è necessario specificare un modificatore all'interno del modello.Trovare i codici colore esadecimali
Trovare il titolo della pagina
Analisi dei log di Apache
Sostituzione delle virgolette doppie con virgolette inglesi
preg_replace("B"b([^"x84x93x94rn]+)b"B", "?1?", $testo); Controllo della complessità della password
WordPress: ottenere immagini di post utilizzando l'espressione regolare
]* />~"; // Esegui preg_match_all per catturare tutte le immagini e salvare i risultati in $aPics preg_match_all($szSearchPattern, $szPostContent, $aPics); // Controlla se abbiamo almeno 1 immagine $iNumberOfPics = count($aPics); if ($iNumberOfPics > 0) ( // Ora qui dovresti fare tutto ciò che devi fare con le immagini // Per questo esempio le immagini vengono visualizzate solo per ($i=0; $i< $iNumberOfPics ; $i++) {
echo $aPics[$i];
};
};
endwhile;
endif;
?>
Conversione di emoticon in immagini
",$testo);
Questo argomento è piuttosto complicato, ma cercherò di coprire brevemente i punti più importanti. Non so quanto successo avrò, ma spero che la lezione sia utile.
Quindi, iniziamo dal fatto che esistono diverse funzioni per lavorare con le espressioni regolari in PHP, ma tre sono quelle più spesso utilizzate:
C'era anche un esempio di utilizzo di preg_match_all, utile per trovare tutti i collegamenti nel testo rimanente. Allora avevamo bisogno di collegamenti perché contenevano le parole chiave che stavamo analizzando. Ecco cosa è successo:Come scrivere frasi regolari
I metacaratteri, a loro volta, possono avere modificatori: 
Bene, ora possiamo passare ad analizzare i nostri schemi regolari dell'ultima lezione. In base ai segnali sopra, proviamo a capire cosa abbiamo. Ecco l'espressione:
Questa è tutta l'espressione, in essa impostiamo la condizione iniziale, quella intermedia e quella finale. Non è difficile, vero? Ecco un'illustrazione per chiarezza: 
Uso generale delle espressioni regolari in PHP
Uso generale delle espressioni regolari in JavaScript
Funzionalità delle espressioni regolari in JavaScript
Principi di composizione di pattern di espressione regolare
o - corrisponde a qualsiasi a, b o c.
o lettere maiuscole.
o qualsiasi numero.
o - Corrisponde a qualsiasi carattere alfabetico minuscolo o maiuscolo.
Opzionale? Corrispondenza 0 o 1.
Asterisco *.
o (1,) non inferiore a 1.
o (1,3) da 1 a 3.
o (1,64) da 1 a 64.
Ecco come appare in PHP: Utilizzo delle espressioni regolari per la convalida
Quando non dovresti utilizzare un'espressione regolare per la convalida?
Convalida utilizzando espressioni regolari
$ è il simbolo del dollaro che indica la fine di una linea.Classi di personaggi escluse
Cerca e sostituisci
Sostituisci le parole in un elenco
Riordinare due numeri
Modifica la formattazione della data
Un semplice esempio di sostituzione di un URL in un tag
\T
- carattere di tabulazione
\N
-nuova linea
\R
- trasferimento in carrozza
\UN
- traduzione del formato
\v
- tabulazione verticale
\UN
- chiamata
\e
- fuga
\033
- Notazione dei simboli ottali
\x1A
- esadecimale
\C[
- simbolo di controllo
\l
- carattere successivo minuscolo
\ u
- maiuscolo -//-
\L
- tutti i caratteri sono minuscoli fino a \E
\U
- in alto -//-
\E
- limitatore di modifica del registro
\Q
- annulla l'azione come metacarattere
