Sostituzione di sottostringhe con preg_replace

Gli argomenti di questa pagina

  • La funzione php preg_replace()
  • Sostituzione di una sottostringa nota con stringa nota
  • Limitare le sostituzioni e conteggio delle sostituzioni
  • Gruppi di caratteri con parentesi quadre e parentesi graffe
  • Parentesi tonde per identificare dei gruppi
  • Uso combinato delle parentesi
  • Formattazione delle date
  • Lavorare con le date
  • Uso di Array con la funzione PHP preg_replace()
  • Array per pattern e per replacement
  • Un solo Array per replacement
  • Un solo Array per pattern
  • La funzione PHP preg_replace() su un Array di valori
  • Usare la funzione PHP preg_replace() su un Array con i gruppi
  • Contare e limitare le sostituzioni con l'uso di Array

Gli esempi di questa pagina

  • Sostituire una parola con un'altra
  • Sostituire un numero con un altro
  • Modificare un TAG HTML vuoto
  • Eliminare spazi da una stringa
  • Modificare il carattere separatore degli elementi della data
  • Sostituire le occorrenze di una sottostringa e mostrare il numero delle sostituzioni
  • Sostituire la prima occorrenza di un numero a quattro cifre
  • Eliminare i numeri
  • Elimina numeri e punteggiatura
  • Modificare il contenuto di un tag
  • Invertire due sottostringhe
  • Uso di segnaposti per manipolare una stringa
  • Modifica il carattere separatore in una data
  • Modificare il formato ed il carattere separatore di una data
  • Modificare una data ed il suo carattere separatore
  • Modificare il formato ed il carattere separatore di una data con orario
  • Eliminare la parte letterale di un codice alfanumerico
  • Modifica dei caratteri separatori in numeri telefonici ed evidenziarli
  • Sostituire l'ultima occorrenza di un numero
  • Trasformare una data da un formato ad un altro e modificare il carattere separatore
  • Uso di array: invio di circolare ad uno o più utenti
  • Array in replacement: sostituire segnaposti con valori
  • Array in pattern per sostituzione di sottostringhe
  • Eliminare la parte numerica di codici memorizzati in un Array
  • Eliminare la parte alfabetica di codici memorizzati in un Array
  • Mostrare una parte interessata dei valori memorizzati in un Array
  • Sostituire alcune sottostringhe con altrettante stringhe
  • Sostituire solo una volta alcune sottostringhe con altrettante stringhe

Questa funzione merita una pagina a parte perchè, fra tutte le altre funzioni viste nella pagina precedente, è la più flessibile e potente. La sua forza sta nell'uso delle REGEX con dei pattern interessanti.

La funzione php preg_replace()

La sintassi: preg_replace ( pattern, replacement, string [, limit], [count])
pattern: può essere una stringa o un array di stringhe.
replacement: è una stringa o un array di stringhe da sostituire. Se questo parametro è una stringa e il parametro pattern è un array, tutti i caratteri corrispondenti al pattern saranno sostituiti da quella stringa. Se il pattern e replacement sono array, tutti i caratteri corrispondenti al pattern saranno sostituiti da replacement. Se ci sono meno elementi della matrice di replacement che nella matrice di pattern, eventuali sostituzioni aggiuntive saranno effettuate da una stringa vuota.
string: è una stringa o una matrice di stringhe in cui cercare e sostituire.
limit (opzionale): le possibili sostituzioni da effettuare per ogni corrispondenza di pattern in ogni stringa. Il valore predefinito è -1 (nessun limite).
count (opzionale): se specificato, questa variabile conterrà il numero di sostituzioni effettuate.

La funzione PHP preg_replace() è case-sensitive.
Fra tutte le funzioni dedicate alla sostituzione di sottostringhe con altre stringhe, forse la funzione PHP preg_replace() è la più completa, ma ha un limite: lavora solo da sinistra a destra di una stringa. Perciò esegue le sostituzioni solo a partire dall'inizio della stringa in esame e non dalla fine della stringa.

Sostituzione di una sottostringa nota con stringa nota

Se la sottostringa da sostituire e la stringa che dovrà prendere il suo posto sono note, le operazioni son sono molto complesse, cone si può notare da questi primi esempi.

Sostituire una parola con un'altra: in questo caso il pattern da preparare è semplice: "/Beccaccia/" ed il replacement è rappresentato da "Beccaria".

preg_replace_1
1
2
3
4
5
6
7
8
9
10
<?php
$stringa 
"Il nonno materno del Manzoni era Cesare Beccaccia, noto illuminista.";
$pattern "/Beccaccia/";
$replacement "Beccaria";
$stringa_modificata preg_replace($pattern$replacement$stringa);
echo 
"La stringa da modificare<br />\n";
echo 
$stringa "<br />\n";
echo 
"La stringa modificata<br />\n";
echo 
$stringa_modificata "<br />\n";
?> 
La stringa da modificare
Il nonno materno del Manzoni era Cesare Beccaccia, noto illuminista.
La stringa modificata
Il nonno materno del Manzoni era Cesare Beccaria, noto illuminista.

Sostituire un numero con un altro: in questo esempio come pattern viene usato '/1821/' e come replacement viene usato '1807'.

preg_replace_2
1
2
3
4
5
6
7
8
9
10
<?php
$stringa 
"Giuseppe Garibaldi è nato nell'anno 1821";
$pattern '/1821/';
$replacement '1807';
$stringa_modificata preg_replace($pattern$replacement$stringa);
echo 
"La stringa da modificare<br />\n";
echo 
$stringa "<br />\n";
echo 
"La stringa modificata<br />\n";
echo 
$stringa_modificata "<br />\n";
?> 
La stringa da modificare
Giuseppe Garibaldi è nato nell'anno 1821
La stringa modificata
Giuseppe Garibaldi è nato nell'anno 1807

Modificare un TAG HTML vuoto: anche quest'operazione non mostra difficoltà. Come pattern viene usato '/<span>/' e come replacement viene usato '<span class="testo_rosso">'.

preg_replace_tag
1
2
3
4
5
6
7
8
9
10
11
12
<?php
$stringa 
"E' possibile abitare in una <span>casa</span> di pietra o in una <span>casa</span> di cemento.";
$pattern '/<span>/';
$replacement '<span class="rosso">';
$stringa_modificata preg_replace($pattern$replacement$stringa);
echo 
"La stringa da modificare<br />\n";
echo 
htmlentities($stringa) . "<br />\n";
echo 
"La stringa modificata<br />\n";
echo 
htmlentities($stringa_modificata) . "<br />\n";
echo 
"che verrà presentato sullo schermo in questo modo:<br />\n";
echo 
$stringa_modificata "<br />\n";
?>
La stringa da modificare
E' possibile abitare in una <span>casa</span> di pietra o in una <span>casa</span> di cemento.
La stringa modificata
E' possibile abitare in una <span class="rosso">casa</span> di pietra o in una <span class="rosso">casa</span> di cemento.
che verrà presentato sullo schermo in questo modo:
E' possibile abitare in una casa di pietra o in una casa di cemento.

Eliminare spazi da una stringa: per questo che potrebbe rappresentare un numero telefonico, come pattern viene usato'/ +/', con lo spazio prima del segno + e come replacement viene usata una stringa vuota '', due apici senza nulla in mezzo.

preg_replace_elimina_spazi
1
2
3
4
5
6
7
8
9
10
<?php
$stringa 
"05  456 52 68";
$pattern '/ +/';
$replacement '';
$stringa_modificata preg_replace($pattern$replacement$stringa);
echo 
"La stringa da modificare<br />\n";
echo 
$stringa "<br />\n";
echo 
"La stringa modificata<br />\n";
echo 
$stringa_modificata "<br />\n";
?>
La stringa da modificare
05 456 52 68
La stringa modificata
054565268

Modificare il carattere separatore degli elementi della data: anche in questo caso i caratteri da cercare col pattern sono noti, ma non necessariamente tutti presenti. Per questo esempio nel pattern '/[-\.\/: ]/', racchiusi tra le parentesi quadre, vengono segnalati i caratteri che più frequentemente vengono usati per separare i vari elementi di una data. Per alcuni di questi caratteri tuttavia è necessario l'uso del carattre di escape reppresentato da una barra rovesciata ( \ ) perchè questi, nelle REGEX sono riservati a compiere particolari funzioni. Il replacement '-' contiene un semplice trattino che sostituirà quelli trovati.

preg_replace_normalizza_data
1
2
3
4
5
6
7
8
9
10
<?php
$stringa 
"18/07/2013";
$pattern '/[-\.\/: ]/';
$replacement '-';
$stringa_modificata preg_replace($pattern$replacement$stringa);
echo 
"La stringa da modificare<br />\n";
echo 
$stringa "<br />\n";
echo 
"La stringa modificata<br />\n";
echo 
$stringa_modificata "<br />\n"
?>
La stringa da modificare
18/07/2013
La stringa modificata
18-07-2013

Limitare le sostituzioni e conteggio delle sostituzioni

Una volta lanciata la funzione PHP preg_replace(), tutte le occorrenze descritte nel pattern vengono sostituite da quel che è descritto in replacement, ma è possibile limitare le sostituzioni aggiungendo il quarto parametro limit.
Se si vuole conoscere il numero di sostituzioni effettuate, è possibile aggiungere il quinto parametro count.
Se normalmente il parametro limit è facoltativo, volendo aggiungere il parametro count, è necessario indicarlo anche se non si intende porre alcun limite alle sostituzioni. In questo caso viene indicato il valore -1, che è il valore predefinito.

Sostituire le occorrenze di una sottostringa e mostrare il numero delle sostituzioni: anche in questo caso viene usato un semplice pattern '/casa/' ed un altrettanto semplice replacement 'abitazione'.
Per consentire tutte le sostituzioni possibili si imposta a -1 il limit e come ultimo parametro si aggiunge il count.
Per limitare il numero delle sostituzioni si assegna un giusto valore all'argomento limit, nell'esempio viene usato 2.

preg_replace_6
1
2
3
4
5
6
7
8
9
10
11
<?php
$stringa 
"Si può abitare in una casa di pietra, in una casa di cemento, in una casa di legno oppure in una casa di mattoni.";
$pattern "/casa/";
$replacement "abitazione";
$stringa_modificata preg_replace($pattern$replacement$stringa, -1$count);
echo 
"La stringa da modificare<br />\n";
echo 
$stringa "<br />\n";
echo 
"La stringa modificata<br />\n";
echo 
$stringa_modificata "<br />\n";
echo 
"Effettuate " $count " sostituzioni<br />\n";
?> 
La stringa da modificare
Si può abitare in una casa di pietra, in una casa di cemento, in una casa di legno oppure in una casa di mattoni.
La stringa modificata
Si può abitare in una abitazione di pietra, in una abitazione di cemento, in una abitazione di legno oppure in una abitazione di mattoni.
Effettuate 4 sostituzioni
preg_replace_7
1
2
3
4
5
6
7
8
9
10
11
<?php
$stringa 
"Si può abitare in una casa di pietra, in una casa di cemento, in una casa di legno oppure in una casa di mattoni.";
$pattern "/casa/";
$replacement "abitazione";
$stringa_modificata preg_replace($pattern$replacement$stringa2$count);
echo 
"La stringa da modificare<br />\n";
echo 
$stringa "<br />\n";
echo 
"La stringa modificata<br />\n";
echo 
$stringa_modificata "<br />\n";
echo 
"Effettuate " $count " sostituzioni<br />\n";
?>
La stringa da modificare
Si può abitare in una casa di pietra, in una casa di cemento, in una casa di legno oppure in una casa di mattoni.
La stringa modificata
Si può abitare in una abitazione di pietra, in una abitazione di cemento, in una casa di legno oppure in una casa di mattoni.
Effettuate 2 sostituzioni

Gruppi di caratteri con parentesi quadre e parentesi graffe

Le parentesi quadre delimitano la classe di appartenenza dei caratteri che racchiudono. In una classe di caratteri specificare un intervallo di caratteri ( [a-z] [2-5] [0-9] ) o un elenco di caratteri ( [aeiouAEIOU] [46fg] ).
Le parentesi graffe indicano il numero esatto, o minimo, o massimo, o l'intervallo di occorrenze di un carattere o di un gruppo di caratteri indicati tra le parentesi quadre ed accettano solo valori numerici al suo interno.
{N}: esattamente N volte
{min, Max}: da min a Max volte
{min,}: minimo min volte
{,Max}: massimo tre volte
Alcuni esempi chiariscono meglio il concetto.

Sostituire la prima occorrenza di un numero a quattro cifre: il pattern è rappresentato da '/[0-9]{4}/' ed il replacement da '1807'. Con questo pattern vengono cercati {4} numeri [0-9] consecutivi per sostituirli col contenuto di replacement. Questi sono i numeri che sono stati trovati. Per cambiare la sola prima occorrenza viene viene impostato il parametro a '1'.

Primo esempio
preg_replace_3
1
2
3
4
5
6
7
8
9
10
11
<?php
$stringa 
"Giuseppe Garibaldi è nato a Nizza il 4 luglio 1821, morto a Caprera il 2 giugno 1882";
$pattern '/[0-9]{4}/';
$replacement '1807';
$stringa_modificata preg_replace($pattern$replacement$stringa1$count);
echo 
"La stringa da modificare<br />\n";
echo 
$stringa "<br />\n";
echo 
"La stringa modificata<br />\n";
echo 
$stringa_modificata "<br />\n";
echo 
"Effettuate " $count " sostituzioni<br />\n";
?> 
La stringa da modificare
Giuseppe Garibaldi è nato a Nizza il 4 luglio 1821, morto a Caprera il 2 giugno 1882
La stringa modificata
Giuseppe Garibaldi è nato a Nizza il 4 luglio 1807, morto a Caprera il 2 giugno 1882
Effettuate 1 sostituzioni

Eliminare i numeri: Per prendere solo la parte letterale di una stringa alfa numerica è possibile usare questa REGEX '/[0-9]/' che elimina tutti i caratteri numerici da una stringa alfanumerica.

preg_replace_numeri
1
2
3
4
5
6
7
8
9
10
<?php
$stringa 
"compro 54 pere,  6 mele, 36 ciliege";
$pattern '/[0-9]/';    
$replacement '';
$stringa_modificata preg_replace($pattern$replacement$stringa);
echo 
"La stringa da modificare<br />\n";
echo 
$stringa "<br />\n";
echo 
"La stringa modificata<br />\n";
echo 
$stringa_modificata "<hr />\n";
?>
La stringa da modificare
compro 54 pere, 6 mele, 36 ciliege
La stringa modificata
compro pere, mele, ciliege

Elimina numeri e punteggiatura: Nelle REGEX si usano le parentesi quadre [ ] per creare una character class, una serie di caratteri da cercare e testare. Generalmente, in una character class, è possibile inserire anche caratteri speciali senza farli precedere dal carattere di escape " \ ". Naturalmente non è escluso che si possano incontrare delle eccezioni.
Fatta questa precisazione in questo esempio viene usato il pattern '/[0-9.,;:?!]/' ed il replacement '' che indica nulla.

preg_replace_numeri_puntegg
1
2
3
4
5
6
7
8
9
10
<?php
$stringa 
"compro 54 pere,  6 mele. 36 ciliege: quelle rosse?!";
$pattern '/[0-9.,;:?!]/';
$replacement '';
$stringa_modificata preg_replace($pattern$replacement$stringa);
echo 
"La stringa da modificare<br />\n";
echo 
$stringa "<br />\n";
echo 
"La stringa modificata<br />\n";
echo 
$stringa_modificata "<hr />\n";
?>
La stringa da modificare
compro 54 pere, 6 mele. 36 ciliege: quelle rosse?!
La stringa modificata
compro pere mele ciliege quelle rosse

Parentesi tonde per identificare dei gruppi

A volte per eseguire delle sostituzioni è necessario usare le parentesi tonde. Questa sintassi viene usata per identificare dei gruppi di caratteri. I gruppi racchiusi dalle parentesi tonde e diventano essenziali nel momento della sostituzione, poiché è possibile richiamarli. Il gruppo può essere richiamato usando la notazione $1 $2 $3 ecc. Questo lo vedreno col prossimo esempio.

Modificare il contenuto di un tag: il pattern da usare è '/(<p.*?>)(.*?)(<.*?p>)/' che crea questi gruppi. Il replacement '$1prova$3' fa uso di due dei tre gruppi e al posto del gruppo mancante viene messa una stringa che dovrà prendere il posto di quella trovata nel secondo gruppo.

preg_replace_tag_2
1
2
3
4
5
6
7
8
9
10
11
12
13
<?php
$stringa 
"<div>Contenuto del div</div>
<p class=\"bordato\">Il contenuto racchiuso in un tag.</p>
<div>qui qualcosa</div>
<p class=\"bordato\">altro contenuto.</p>"
;
$pattern '/(<p.*?>)(.*?)(<.*?p>)/';
$replacement '$1prova$3';
$stringa_modificata preg_replace($pattern$replacement$stringa);
echo 
"La stringa da modificare<br />\n";
echo 
nl2br(htmlentities($stringa)) . "<br /><br />\n";
echo 
"La stringa modificata<br />\n";
echo 
nl2br(htmlentities($stringa_modificata)) . "<br />\n";
?>
La stringa da modificare
<div>Contenuto del div</div>
<p class="bordato">Il contenuto racchiuso in un tag.</p>
<div>qui qualcosa</div>
<p class="bordato">altro contenuto.</p>

La stringa modificata
<div>Contenuto del div</div>
<p class="bordato">prova</p>
<div>qui qualcosa</div>
<p class="bordato">prova</p>

Uso combinato delle parentesi

La forza delle REGEX sta proprio nell'uso combinato dei tre tipi di parentesi.

Invertire due sottostringhe: per risolvere il problema vengono creati tre gruppi di caratteri come mostrato da questa immagine. Il pattern è rappresentato da '/([a-zA-Z]+)(, )([a-z]+)/' ed usa, appunto, le parentesi quadre per definire le classi di caratteri e le parentesi tonde per definire i gruppi. Il replacement è costituito da da '$3 $1' che rappresentano il terzo ed il primo elemento trovati. Non viene usato $2 che rappresenta la virgola in questo caso non necessario. Questo fa sì che le due sottostringhe vengano invertite e che scompaia la virgola e lo spazio non necessari.

preg_replace_13
1
2
3
4
5
6
7
8
9
10
11
<?php
$stringa 
"samuele, sono";
$pattern '/([a-zA-Z]+)(, )([a-z]+)/';
$replacement '$3 $1';
$stringa_modificata preg_replace($pattern$replacement$stringa, -1$count);
echo 
"La stringa da modificare<br />\n";
echo 
$stringa "<br />\n";
echo 
"La stringa modificata<br />\n";
echo 
$stringa_modificata "<br />\n";
echo 
"Effettuate " $count " sostituzioni<br />\n";
?> 
La stringa da modificare
samuele, sono
La stringa modificata
sono samuele
Effettuate 1 sostituzioni

Uso di segnaposti per manipolare una stringa: in questo esempio viene usata una stringa con dei particolari segnaposti rappresentati da una coppia di parentesi graffe con dentro una stringa {subtitle}.....{/subtitle}. Il pattern '/(\{subtitle\})(.*?)(\{\/subtitle\})/is' individua i due segnaposto di apertura e chiusura della zona ed i loro contenuti creando tre serie di gruppi di caratteri come mostrato in questa immagine. Il replacement '<strong>$2</strong>' individua il secondo gruppo di ciascuna serie e gli da il grassetto.

preg_replace_13_a
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?php
$stringa 
"{subtitle}Sottotitolo per il primo paragrafo{/subtitle}<br />
Il primo paragrafo<br />
{subtitle}Sottotitolo per il secondo paragrafo{/subtitle}<br />
Secondo paragrafo<br />"
;
$pattern '/(\{subtitle\})(.*?)(\{\/subtitle\})/is';
$replacement '<strong>$2</strong>';
$stringa_modificata preg_replace($pattern$replacement$stringa, -1$count);
echo 
"La stringa da modificare<br />\n";
echo 
$stringa "<br />\n";
echo 
"La stringa modificata: primo metodo<br />\n";
echo 
$stringa_modificata "<br />\n";
echo 
"Effettuate " $count " sostituzioni<br />\n";
?> 
La stringa da modificare
{subtitle}Sottotitolo per il primo paragrafo{/subtitle}
Il primo paragrafo
{subtitle}Sottotitolo per il secondo paragrafo{/subtitle}
Secondo paragrafo

La stringa modificata: primo metodo
Sottotitolo per il primo paragrafo
Il primo paragrafo
Sottotitolo per il secondo paragrafo
Secondo paragrafo

Effettuate 2 sostituzioni

Formattazione delle date

Modifica il carattere separatore in una data: Nell'esempio abbiamo due formati di date: gg mm aaaa e aaaammgg. Coi due pattern '/([0-9]{2}) ([0-9]{2}) ([0-9]{4})/' e '/([0-9]{4})([0-9]{2})([0-9]{2})/' vengono individuati i tre gruppi di caratteri che compongono le due date in questione. Nel replacement '$1-$2-$3' vengono presi i tre gruppi e concatenati tramite un trattino.

preg_replace_13_b
1
2
3
4
5
6
7
8
9
10
11
12
<?php
$stringa 
"data it: 12 01 1947";
$pattern '/([0-9]{2}) ([0-9]{2}) ([0-9]{4})/';
$replacement '$1-$2-$3';
$stringa_modificata preg_replace($pattern$replacement$stringa);
echo 
$stringa_modificata "<br />\n";
$stringa "data am: 20140821";
$pattern '/([0-9]{4})([0-9]{2})([0-9]{2})/';
$replacement '$1-$2-$3';
$stringa_modificata preg_replace($pattern$replacement$stringa);
echo 
$stringa_modificata "<br />\n";
?> 
data it: 12-01-1947
data am: 2014-08-21

Modificare il formato ed il carattere separatore di una data: dal formato AAAA/MM/GG otteniamo il formato GG-MM-AAAA. Col pattern '/([0-9]{4})\/([0-9]{2})\/([0-9]{2})/' vengono formati i tre gruppi e poi col replacement '$3-$2-$1', invertendo i gruppi, uniti dal trattino, otteniamo il formato desiderato.

preg_replace_5
1
2
3
4
5
6
7
8
9
10
<?php
$stringa 
"Io sono nato il 2007/01/25";
$pattern '/([0-9]{4})\/([0-9]{2})\/([0-9]{2})/';
$replacement '$3-$2-$1';
$stringa_modificata preg_replace($pattern$replacement$stringa);
echo 
"La stringa da modificare<br />\n";
echo 
$stringa "<br />\n";
echo 
"La stringa modificata<br />\n";
echo 
$stringa_modificata "<br />\n";
?> 
La stringa da modificare
Io sono nato il 2007/01/25
La stringa modificata
Io sono nato il 25-01-2007

Modificare una data ed il suo carattere separatore: in questo esempio, oltre a cambiare il carattere separatore della data viene cambiato anche il giorno. Per far questo viene usato il pattern '/([0-9]{2})\/([0-9]{2})\/([0-9]{4})/' ed il replacement '10-$2-$3'. Da notare che al posto del previsto $1 abbiamo un numero, nel nostro esempio, 10.

preg_replace_4
1
2
3
4
5
6
7
8
9
10
<?php
$stringa 
"Io sono nato il 15/04/2003";
$pattern '/([0-9]{2})\/([0-9]{2})\/([0-9]{4})/'
$replacement '10-$2-$3';
$stringa_modificata preg_replace($pattern$replacement$stringa);
echo 
"La stringa da modificare<br />\n";
echo 
$stringa "<br />\n";
echo 
"La stringa modificata<br />\n";
echo 
$stringa_modificata "<br />\n";
?> 
La stringa da modificare
Io sono nato il 15/04/2003
La stringa modificata
Io sono nato il 10-04-2003

Modificare il formato ed il carattere separatore di una data con orario: in questo esempio trasformiamo il formato della data da aaaa-mm-gg hh:mm:ss a gg-mm-aaaa hh:mm:ss. Per compiere questo lavoro usiamo il pattern '/(\d{4})-(\d{2})-(\d{2})\s(\d{2}:\d{2}:\d{2})/' che crea 4 gruppi di caratteri, come visibile in questa immagine. Il quarto gruppo comprende tutto l'orario nel formato hh:mm:ss. Col replacement '$3/$2/$1 $4' viene costruita la nuova data nel formato e col carattere separatore da noi desiderato.

preg_replace_13a
1
2
3
4
5
6
7
8
9
10
11
<?php
$stringa 
"Inviato da Bianchi il 2007-02-15 02:43:41";
$pattern '/(\d{4})-(\d{2})-(\d{2})\s(\d{2}:\d{2}:\d{2})/';
$replacement '$3/$2/$1 $4';
$stringa_modificata preg_replace($pattern$replacement$stringa, -1$count);
echo 
"La stringa da modificare<br />\n";
echo 
$stringa "<br />\n";
echo 
"La stringa modificata<br />\n";
echo 
$stringa_modificata "<br />\n";
echo 
"Effettuate " $count " sostituzioni<br />\n";
?> 
La stringa da modificare
Inviato da Bianchi il 2007-02-15 02:43:41
La stringa modificata
Inviato da Bianchi il 15/02/2007 02:43:41
Effettuate 1 sostituzioni

Eliminare la parte letterale di un codice alfanumerico: data una stringa che potrebbe rappresentare un qualsiasi codice alfanumerico per eliminare la parte letterale, si organizza un pattern '/(\d{3})-([A-Za-z]{2})-(\d{3})/' in grado di creare tre gruppi e nel replace '$1-$3' si descrivono i soli gruppi di stringhe numeriche.

preg_replace_13b
1
2
3
4
5
6
7
8
9
10
11
<?php
$stringa 
"333-ab-4444";
$pattern '/(\d{3})-([A-Za-z]{2})-(\d{3})/';
$replacement '$1-$3';
$stringa_modificata preg_replace($pattern$replacement$stringa, -1$count);
echo 
"La stringa da modificare<br />\n";
echo 
$stringa "<br />\n";
echo 
"La stringa modificata<br />\n";
echo 
$stringa_modificata "<br />\n";
echo 
"Effettuate " $count " sostituzioni<br />\n";
?> 
La stringa da modificare
333-ab-4444
La stringa modificata
333-4444
Effettuate 1 sostituzioni

Modifica dei caratteri separatori in numeri telefonici ed evidenziarli: il pattern '/(\d{2,4})-(\d{5,9})/' crea i due gruppi di caratteri, come viene mostrato in questa immagine, mentre il replacement '<span class="rosso">$1 $2</span>' provvede a cambiare il carattere separatore e ad evidenziare i numeri

preg_replace_13_c
1
2
3
4
5
6
7
8
9
10
11
<?php
$stringa 
"Ciao, il mio cell è 555-446677 <br />mentre il tel è 12-45678958";
$pattern '/(\d{2,4})-(\d{5,9})/';
$replacement '<span class="rosso">$1 $2</span>';
$stringa_modificata preg_replace($pattern$replacement$stringa, -1$count);
echo 
"La stringa da modificare<br />\n";
echo 
$stringa "<br />\n";
echo 
"La stringa modificata<br />\n";
echo 
$stringa_modificata "<br />\n";
echo 
"Effettuate " $count " sostituzioni<br />\n";
?> 
La stringa da modificare
Ciao, il mio cell è 555-446677
mentre il tel è 12-45678958
La stringa modificata
Ciao, il mio cell è 555 446677
mentre il tel è 12 45678958
Effettuate 2 sostituzioni

Sostituire l'ultima occorrenza di un numero:per questa richiesta ci sono due possibili scenari:

  • L'ultima occorrenza del numero si trova alla fine della stringa
  • L'ultima occorrenza del numero è seguita da altri caratteri

L'ultima occorrenza del numero si trova alla fine della stringa: siamo ancora con un esempio semplice. Il pattern usato è '/[0-9]{4}$/' che cattura la sottostringa numerica che si triva alla fine della stringa in esame. Il replacement '1883' provvede a sostituire la sottostringa trovata col valore indicato. Alla fine del pattern viene aggiunto il simbolo del dollaro ( $ ) per indicare che si intende cercare l'ultima occorrenza del numero che si trova alla fine della stringa. Tra gli argomenti della funzione php preg_replace() non è necessario il limitatore di sostituzioni, che resta comunque opzionale.

Secondo esempio
preg_replace_3a
1
2
3
4
5
6
7
8
9
10
11
12
<?php
$stringa 
"Giuseppe Garibaldi è nato a Nizza il 4 luglio 1821, morto a Caprera il 2 giugno 1882";
$pattern '/[0-9]{4}$/';
$replacement '1883';
//$stringa_modificata = preg_replace($pattern, $replacement, $stringa, 1, $count);
$stringa_modificata preg_replace($pattern$replacement$stringa);
echo 
"La stringa da modificare<br />\n";
echo 
$stringa "<br />\n";
echo 
"La stringa modificata<br />\n";
echo 
$stringa_modificata "<br />\n";
echo 
"Effettuate " $count " sostituzioni<br />\n";
?> 
La stringa da modificare
Giuseppe Garibaldi è nato a Nizza il 4 luglio 1821, morto a Caprera il 2 giugno 1882
La stringa modificata
Giuseppe Garibaldi è nato a Nizza il 4 luglio 1821, morto a Caprera il 2 giugno 1883
Effettuate 2 sostituzioni

L'ultima occorrenza del numero è seguita da altri caratteri: per questa richiesta, che è la più complessa, vengono proposte alcune soluzioni interessanti che mi sono state proposte da alcuni esperti nel settore. Infatti la funzione PHP preg_replace() non è in grado di effettuare le sostituzioni a partire dalla fine della stringa.

Prima soluzione: uso dell'abbinamento di altre funzioni PHP.
Prima di usare la funzione PHP preg_replace() che in questa pagina stiamo testando dobbiamo far sì che l'ultima occorrenza del numero che stiamo cercando venga a trovarsi all'inizio della stringa.
Per far questo dobbiamo usare alcune funzioni PHP.
La funzione PHP preg_match_all() trova tutte le occorrenze del numero cercato.
Il costrutto list() estrae l'ultima occorrenza del numero e la sua posizione nella stringa in esame.
La prima funzione PHP substr() estrae la prima parte della stringa in esame fino alla posizione del numero cercato.
La seconda funzione PHP substr() estrae la parte finale della stringa in esame a partire dal numero cercato.
Ora possiamo applicare la funzione PHP preg_replace() alla seconda sottostringa in quanto il numero cercato è ora alla prima posizione della stessa sottostringa.
A questo punto basta concatenare la prima sottostringa con la stringa appena modificata o, meglio, possiamo usare tutti questi passaggi in una unica istruzione come è suggerito dal frammento di codice qui sotto riportato. In questo script viene usato il pattern '/[0-9]{4}/' ed il replacement '1883'.
Usando l'istruzione finale, possiamo fare a meno delle istruzioni intermedie lasciate solo come dimostrazione dei passaggi effettuati.
Alla fine di questo script, a puro scopo didattico e, soprattutto, a futura memoria, viene eseguito il test che mostra tutti i passaggi effettuati.

Terzo esempio primo test: metodo ZioLuffio
preg_replace_3b
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
<?php
$stringa 
"Giuseppe Garibaldi è nato a Nizza il 4 luglio 1821, il 2 giugno 1882 è morto a Caprera";
$pattern '/[0-9]{4}/';
$replacement '1883';
if(
$count preg_match_all($pattern$stringa$matchesPREG_OFFSET_CAPTURE)){
    list(
$found$offset) = $matches[0][count($matches[0])-1];
    
//    =========================================
    
$part1 substr($stringa0$offset);
    
$part2 substr($stringa$offset);
    
$modif preg_replace($pattern$replacementsubstr($stringa$offset));
//    $stringa_modificata = $part1 . $modif;
    //    =========================================
    
$stringa_modificata substr($stringa0$offset) . preg_replace($pattern$replacementsubstr($stringa$offset));
}
echo 
"La stringa da modificare<br />\n";
echo 
$stringa "<br />\n";
echo 
"La stringa modificata<br />\n";
echo 
$stringa_modificata "<hr />\n";
//    stampa del test solo a titolo dimostrativo
echo "trovate " $count " occorrenze per gli anni ma sostituito solo " $found " con " $replacement "<br />\n";
echo 
"Match found<br />\n";
foreach ( 
$matches[0] as $chiave => $valore) {
    foreach ( 
$valore as $key => $value) {
        echo 
$key " => " $value "<br />\n";
    }
}
echo 
"<pre>\n";
echo 
"prima parte della stringa: '" $part1 "'\n";
echo 
"altra parte della stringa: '" $part2 "'\n";
echo 
"Parte della stringa modif: '" $modif "'\n";
echo 
"</pre>\n";
?> 
La stringa da modificare
Giuseppe Garibaldi è nato a Nizza il 4 luglio 1821, il 2 giugno 1882 è morto a Caprera
La stringa modificata
Giuseppe Garibaldi è nato a Nizza il 4 luglio 1821, il 2 giugno 1883 è morto a Caprera
trovate 2 occorrenze per gli anni ma sostituito solo 1882 con 1883
Match found
0 => 1821
1 => 47
0 => 1882
1 => 65
prima parte della stringa: 'Giuseppe Garibaldi è nato a Nizza il 4 luglio 1821, il 2 giugno '
altra parte della stringa: '1882 è morto a Caprera'
Parte della stringa modif: '1883 è morto a Caprera'

Seconda soluzione: uso della funzione PHP strrev().
Per sopperire alla incapacità della funzione PHP preg_replace() di lavorare a ritroso sulla stringa in esame, si fa uso della funzione PHP strrev() per capovolgere la stringa. In questo modo aggiriamo il problema eseguendo la sostituzione sulla prima occorrenza trovata dal pattern '/[0-9]{4}/'. Ovviamente anche replacement '1807' viene invertito prima della sostituzione.

Terzo esempio secondo test: metodo badaze
preg_replace_3c
1
2
3
4
5
6
7
8
9
10
11
<?php
$stringa 
"Giuseppe Garibaldi è nato a Nizza il 4 luglio 1821, morto a Caprera il 2 giugno 1882 alle 15.45";
$pattern '/[0-9]{4}/';
$replacement '1807';
$stringa_modificata strrev(preg_replace($patternstrrev($replacement), strrev($stringa), 1$count));
echo 
"La stringa da modificare<br/>";
echo 
$stringa."<br/>";
echo 
"La stringa modificata<br />\n";
echo 
$stringa_modificata "<br />\n";
echo 
"Effettuate " $count " sostituzioni<br />\n";
?> 
La stringa da modificare
Giuseppe Garibaldi è nato a Nizza il 4 luglio 1821, morto a Caprera il 2 giugno 1882 alle 15.45
La stringa modificata
Giuseppe Garibaldi è nato a Nizza il 4 luglio 1821, morto a Caprera il 2 giugno 1807 alle 15.45
Effettuate 1 sostituzioni

Terza soluzione: usare un pattern più complesso con una tecnica chiamata "negative lookahead".
lookahead (controlla davanti) impone una condizione sul testo che viene dopo.
Il costrutto lookahead negativo è racchiuso in una coppia di parentesi. La parentesi di apertura è seguita da un punto interrogativo e un punto esclamativo, quindi la REGEX che ci interessa ed ha questo schema:
/element(?!pattern)/
element corrisponde al primo [0-9]{4}
pattern corrisponde a .*[0-9]{4}
?! significa "si catturano i soli caratteri descritti in element che non sono seguiti da altre corrispondenze del pattern".
Siccome l'ultimo anno non è seguito da un'altra occorrenza allora viene catturato. Con questa tecnica catturo l'ultima occorrenza che l'elemento cercato occupa nella stringa in esame.
Per far questo si usa il pattern '/[0-9]{4}(?!.*[0-9]{4})/' ed il replacement '1883'.

Terzo esempio terzo test: metodo badaze
preg_replace_3d
1
2
3
4
5
6
7
8
9
10
11
12
<?php
$stringa 
"Giuseppe Garibaldi è nato a Nizza il 4 luglio 1821, vissuto tra il 1821 ed il 1882, morto a Caprera il 2 giugno 1885 alle 15.45";
//$pattern = "~[0-9]{4}(?!.*[0-9]{4})~";
$pattern '/[0-9]{4}(?!.*[0-9]{4})/';
$replacement '1883';
$stringa_modificata preg_replace($pattern$replacement$stringa1$count);
echo 
"La stringa da modificare<br/>";
echo 
$stringa."<br/>";
echo 
"La stringa modificata<br />\n";
echo 
$stringa_modificata "<br />\n";
echo 
"Effettuate " $count " sostituzioni<br />\n";
?> 
La stringa da modificare
Giuseppe Garibaldi è nato a Nizza il 4 luglio 1821, vissuto tra il 1821 ed il 1882, morto a Caprera il 2 giugno 1885 alle 15.45
La stringa modificata
Giuseppe Garibaldi è nato a Nizza il 4 luglio 1821, vissuto tra il 1821 ed il 1882, morto a Caprera il 2 giugno 1883 alle 15.45
Effettuate 1 sostituzioni

Lavorare con le date

NOTA IMPORTANTE: Finora come pattern ho usato, ove necessario, l'espresssione regolare '/([0-9]{4})-([0-9]{2})-([0-9]{2})/'.
Questa tuttavia ha un linite: prende anche 0000-00-00 oppure 0180-65-83 che non sono date.
Se la data proviene da fonte attendibile potrebbe ancora andar bene.
Ma se la fonte non è attendibile è consigliabile usare una REGEX che, anche se ancora imperfetta, limiti almeno gli errori più banali:
'/([12]+[0-9]{3})-{1}([01]+[0-9]{1})-{1}([0123]+[0-9]{1})/' .
Con questa si è sicuri che l'anno dovrà per forza cominciare con 1 o 2, il mese con 0 o 1, il giorno con 0, 1, 2 o 3.

Tuttavia resta ancora una piccola incertezza sulla esattezza della data in quanto si potrebbero avere delle date quali 2014-02-31, 2014-04-31 o altre simili che sono date che non esistono. Per non parlare del 2014-02-29 che è giusta per un anno bisestile, ma non giusta per tutti gli altri anni non bisestili.
La funzione PHP checkdate() resta comunque un valido strumento per controllare l'esattezza delle date e comunque va eseguita prima o dopo l'uso della REGEX.
La funzione preg_replace() va in ogni caso tentata per mantenere lo stesso formato per tutte le date della pagina. E' una questione estetica per la presentazione della pagina.

Altra nota: in tutti gli esempi di questa pagina si presuppone di conoscere già il formato della data ossia se la data è rappresentata come AAAA MM GG piuttosto che GG MM AAAA, a parte il carattere separatore dei vari elementi

Per i prossimi esercizi vengono usati i gruppi che sono una sequenza di caratteri all'interno di parentesi tonde e sono interpretati come un'unica entità dall'interprete delle REGEX.
I gruppi diventano essenziali nel momento della sostituzione, poiché è possibile richiamarli nell'ordine desiderato. Infatti è possibile richiamarli nel replacement con dei dollari ( $ ) seguiti da un numero in maniera sequenziale: $0 $1 $2 ecc, come mostrato In alcuni esercizi mostrati qui sotto.

Trasformare una data da un formato ad un altro e modificare il carattere separatore: nell'esempio qui sotto vengono mostrati, ma commentati, alcuni pattern più generici che potrebbero servire per lo scopo. Ma quello più valido è rappresentato dall'ultimo pattern /([12]+[0-9]{3})-([01]+[0-9]{1})-([0123]+[0-9]{1})/ che è quello che viene usato. Il replacement è rappresentato da '$3/$2/$1'. Nella stringa in esame ci sono due date, ma, come dimostra questa immagine, è stata catturata la sola data che nella stringa in esame ha come carattere separatore un trattino, l'altra data che ha la barra inclinata non viene catturata. Questo perchè nel pattern, oltre ai gruppi di numeri, è stato indicato il trattino. Per questo motivo la data che usa come carattere separatore una barra inclinata, non viene catturata.

preg_replace_normalizza_data_2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?php
$stringa 
"Il giorno 2005/08/29 vado in vacanza e il 2005-10-15 finisco la vacanza";
//$pattern = '/\d{4}[\/\.]\d{2}[\/\.]\d{2}/';
//$pattern = '/(.{4})-(.{2})-(.{2})/';
//$pattern = '/([0-9]{4})-([0-9]{2})-([0-9]{2})/';
//$pattern = "/(\d+)-(\d+)-(\d+)/"; 
$pattern '/([12]+[0-9]{3})-([01]+[0-9]{1})-([0123]+[0-9]{1})/';
$replacement '$3/$2/$1';
$stringa_modificata preg_replace($pattern$replacement$stringa);
echo 
"La stringa da modificare<br />\n";
echo 
$stringa "<br />\n";
echo 
"La stringa modificata<br />\n";
echo 
$stringa_modificata "<br />\n"
?>
La stringa da modificare
Il giorno 2005/08/29 vado in vacanza e il 2005-10-15 finisco la vacanza
La stringa modificata
Il giorno 2005/08/29 vado in vacanza e il 15/10/2005 finisco la vacanza

Questo esempio è simile a quello di sopra: Il pattern è '/([12]+[0-9]{3})\/([01]+[0-9]{1})\/([0123]+[0-9]{1})/' ed il replacement è '$3-$2-$1'.
Tuttavia anche qui, come è mostrato in questa immagine, viene catturata una sola data e precisamente quella che come carattere separatore ha la barra inclinata e non quella col trattino. Questo perchè nel pattern è indicata la barra inclinata anzichè il trattino.

preg_replace_normalizza_data_3
1
2
3
4
5
6
7
8
9
10
<?php
$stringa 
"Il giorno 2005/08/29 vado in vacanza e il 2005-10-15 finisco la vacanza";
$pattern '/([12]+[0-9]{3})\/([01]+[0-9]{1})\/([0123]+[0-9]{1})/';
$replacement '$3-$2-$1';
$stringa_modificata preg_replace($pattern$replacement$stringa);
echo 
"La stringa da modificare<br />\n";
echo 
$stringa "<br />\n";
echo 
"La stringa modificata<br />\n";
echo 
$stringa_modificata "<br />\n"
?>
La stringa da modificare
Il giorno 2005/08/29 vado in vacanza e il 2005-10-15 finisco la vacanza
La stringa modificata
Il giorno 29-08-2005 vado in vacanza e il 2005-10-15 finisco la vacanza

L'esempio definitivo per la normalizzazione delle date:
Negli ultimi due esempi, nella REGEX, abbiamo scelto selettivamente uno specifico carattere separatore. In quest'ultimo esempio vogliamo eseguire una selezione indiscriminata di qualsiasi carattere separatore possa trovarsi nella descrizione di una data. Il pattern da usare è come questo: /[-\.\/: ]/. Questo pattern verrà inserito in quello già visto tra un gruppo ed un altro.
Nel nuovo pattern va inserito entro parentesi quadre ( [-\.\/: ] ), tra un gruppo ed un altro: /([12]+[0-9]{3})[-\.\/: ]{1}([01]+[0-9]{1})[-\.\/: ]{1}([0123]+[0-9]{1})/. In questo modo il carattere separatore viene solo intercettato ma non incluso tra i gruppi, come dimostra questa immagine. Finalmente abbiamo le due date ed è su entrambe che vogliamo agire.

preg_replace_normalizza_data_4
1
2
3
4
5
6
7
8
9
10
11
<?php
$stringa 
"Il giorno 2005/08/29 vado in vacanza e il 2005-10-15 finisco la vacanza";
$pattern '/([12]+[0-9]{3})[-\.\/: ]{1}([01]+[0-9]{1})[-\.\/: ]{1}([0123]+[0-9]{1})/';
$replacement '$3-$2-$1';
$stringa_modificata preg_replace($pattern$replacement$stringa, -1$count);
echo 
"La stringa da modificare<br />\n";
echo 
$stringa "<br />\n";
echo 
"La stringa modificata<br />\n";
echo 
$stringa_modificata "<br />\n";
echo 
"Effettuate " $count " sostituzioni<br />\n";
?>
La stringa da modificare
Il giorno 2005/08/29 vado in vacanza e il 2005-10-15 finisco la vacanza
La stringa modificata
Il giorno 29-08-2005 vado in vacanza e il 15-10-2005 finisco la vacanza
Effettuate 2 sostituzioni

Uso di Array con la funzione PHP preg_replace()

La funzione PHP preg_replace() Ammette anche l'uso di Array per gli argomenti pattern e/o replacement.
Vedremo ora dei semplici esempi per

  • Due Array per pattern e per replacement
  • Un solo Array per replacement
  • Un solo Array per pattern
  • Un Array di valori da manipolare

Array per pattern e per replacement

Questa tecnica la si può usare utilizzando un Array per il pattern ed un Array per il replacement.

Uso di array: invio di circolare ad uno o più utenti: i passi da seguire:

  • S prepara il testo fisso con dei segnaposti al posto dei dati reali. Questi dati possono essere prelevati da un form o da un DB. E' importante che i segnaposti da inserire nel testo siano tutti differenti e che sicuramente non vengano usati come parte integrante del testo: es. io sono nato il nato. Per questo motivo vengono usate delle stringhe particolari. Nell'esempio ci sono due stringhe fondamentalmente uguali, ma con segnaposti di tipo differente: nella prima stringa uso nomi espliciti dei campi che debbono essere ospitati (::nome:: ::data:: ecc), nella seconda stringa ho usato dei generici A1 A2 ecc.
  • Nell'Array pattern vengono riportati i segnaposti così come sono stati posti nel testo, uno per ogni campo e non ripetuti.
  • Nell'Array replacement vengono posti i valori corrispondenti a ciascun campo memorizzato nell'Array pattern e nello stesso ordine.

Compiuti questi passi preliminari è sufficiente invocare la funzione PHP preg_replace() nel consueto modo già visto negli esercizi già visti.
E' da notare che, almeno in questo caso, è necessario che i record dell'Array replacement e quelli dell'Array pattern corrispondano perfettamente, pena un risultato incomprensibile.
Nell'esempio qui sotto ho lasciato i due sistemi di segnaposto (quello ::nome campo:: e quello A1), di cui uno è commentato. Entrambi funzionano alla stessa maniera.

preg_replace_8
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
<?php
/*
$stringa = "Il sottoscritto ::nome:: nato il ::data:: e abitante in ::città:: chiede ::chiede::.
Le lezioni inizieranno oggi a ::città:: vicino a ::via:: alle ore ::ore::.
Con ossequi
::nome::";
$pattern = array(
"/::nome::/",
"/::data::/",
"/::città::/",
"/::via::/",
"/::chiede::/",
"/::ore::/"
);
*/
$stringa "Il sottoscritto A1 nato il A2 e abitante in A3 chiede A5.
Le lezioni inizieranno oggi a A3 vicino a A4 alle ore A6.
Con ossequi
A1"
;
$pattern = array(
"/A1/",
"/A2/",
"/A3/",
"/A4/",
"/A5/",
"/A6/"
);

$replacement = array(
'Gigi',
'9/6/1988',
'Roma',
'Via Manzoni',
'di essere ammesso al corso di scienziato',
'19:30'
);
$stringa_modificata preg_replace($pattern,$replacement,$stringa,-1,$count);
echo 
nl2br($stringa_modificata) . "<br />\n";
echo 
"Effettuate " $count " sostituzioni<br />\n";
?> 
Il sottoscritto Gigi nato il 9/6/1988 e abitante in Roma chiede di essere ammesso al corso di scienziato.
Le lezioni inizieranno oggi a Roma vicino a Via Manzoni alle ore 19:30.
Con ossequi
Gigi
Effettuate 8 sostituzioni

L'esempio successivo è come il precedente ma ha dei segnaposti differenti ed il relativo Array per il pattern ne rispecchia la modifica. In questo esempio per il pattern viene usato un Array associativo per rendere più comprensibile il senso dei nomi assegnati ai segnaposti.

preg_replace_8a
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?php
$stringa 
"Il sottoscritto ::primo:: nato il ::secondo:: e abitante in ::terzo:: chiede ::quinto::.
Le lezioni inizieranno oggi a ::terzo:: vicino a ::quarto:: alle 20.30.
Con ossequi
::primo::"
;
$pattern = array(
"/::primo::/",
"/::secondo::/",
"/::terzo::/",
"/::quarto::/",
"/::quinto::/"
);
$replacement = array(
'nome' => 'Bianchi',
'nato' => '11/11/1966',
'citta' => 'Genova',
'via' => 'Piazza Napoli',
'chiede' => 'di essere ammesso al corso di cuochi'
);
$stringa_modificata preg_replace($pattern,$replacement,$stringa,-1,$count);
echo 
nl2br($stringa_modificata) . "<br />\n";
echo 
"Effettuate " $count " sostituzioni<br />\n";
?> 
Il sottoscritto Bianchi nato il 11/11/1966 e abitante in Genova chiede di essere ammesso al corso di cuochi.
Le lezioni inizieranno oggi a Genova vicino a Piazza Napoli alle 20.30.
Con ossequi
Bianchi
Effettuate 7 sostituzioni

In questo esempio l'Array pattern ha un elemento in meno rispetto all'Array replacement. Questo fatto rende il messaggio finale incompleto ed incomprensibile.

preg_replace_8b
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php
$stringa 
"Il sottoscritto ::nome:: nato il ::data:: e abitante in ::città:: chiede ::chiede::.
Le lezioni inizieranno oggi a ::città:: vicino a ::via:: alle 20.30.
Con ossequi
::nome::"
;
$pattern = array(
"/::nome::/",
"/::data::/",
"/::città::/",
"/::chiede::/"
);
$replacement = array(
'Rossi',
'21/03/51',
'Paperopoli',
'Piazza dei denari',
'di essere iniziare il tirocinio'
);
$stringa_modificata preg_replace($pattern,$replacement,$stringa,-1,$count);
echo 
nl2br($stringa_modificata) . "<br />\n";
echo 
"Effettuate " $count " sostituzioni<br />\n";
?> 
Il sottoscritto Rossi nato il 21/03/51 e abitante in Paperopoli chiede Piazza dei denari.
Le lezioni inizieranno oggi a Paperopoli vicino a ::via:: alle 20.30.
Con ossequi
Rossi
Effettuate 6 sostituzioni

Un solo Array per replacement

Array in replacement: sostituire segnaposti con valori. In questo esempio si fa uso della funzione PHP array_shift() che ad ogni iterazione sull'Array rimuovere il primo elemento da un Array, e, se necessario, restituire il valore dell'elemento rimosso.
Per far questo si mettono dei segnaposti in precise posizioni della stringa in esame e si crea un Array di valori per il replacement.
Con array_shift($replacement) come argomento della funzione PHP preg_replace() si permette all'interprete REGEX di prendere dall'Array un elemento alla volta col quale sostituire il segnaposto della stringa in esame.
Come pattern si ha  '/:\\w+/e' mentre come pattern si ha un Array.

preg_replace_11
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?php
$stringa 
"Il sottoscritto :001 nato il :001 e abitante in :001 chiede: :001.
Le lezioni inizieranno oggi a :001 vicino a :001 alle 20.30.
Con ossequi 
:001"
;
$pattern '/:\\w+/e';
$replacement = array(
'Rossi',
'21/03/51',
'Paperopoli',
'di essere ammesso al corso di cuochi',
'Paperopoli',
'Piazza dei denari',
'Rossi'
);
$stringa_modificata preg_replace($pattern'array_shift($replacement)'$stringa);
echo 
"La stringa da modificare<br />\n";
echo 
$stringa "<br />\n";
echo 
"La stringa modificata<br />\n";
echo 
nl2br($stringa_modificata) . "<br />\n";
?> 
La stringa da modificare
Il sottoscritto :001 nato il :001 e abitante in :001 chiede: :001. Le lezioni inizieranno oggi a :001 vicino a :001 alle 20.30. Con ossequi :001
La stringa modificata
Il sottoscritto Rossi nato il 21/03/51 e abitante in Paperopoli chiede: di essere ammesso al corso di cuochi.
Le lezioni inizieranno oggi a Paperopoli vicino a Piazza dei denari alle 20.30.
Con ossequi
Rossi

Un solo Array per pattern

Array in pattern per sostituzione di sottostringhe: in questa situazione torniamo ad un esempio semplice. In pattern viene creato un Array di parole da cercare, in replacement la parola che dovrà prendere il posto delle parole cercate.

preg_replace_11_a
1
2
3
4
5
6
7
8
9
10
<?php
$stringa 
"Oggi a pranzo ho mangiato una mela. Dopo pranzo berrò un succo di pera nel bicchiere. La pera è buona.";
$pattern = array('/mela/','/pera/');
$replacement 'pesca';
$stringa_modificata preg_replace($pattern$replacement$stringa);
echo 
"La stringa da modificare<br />\n";
echo 
$stringa "<br />\n";
echo 
"La stringa modificata<br />\n";
echo 
$stringa_modificata "<hr />\n";
?> 
La stringa da modificare
Oggi a pranzo ho mangiato una mela. Dopo pranzo berrò un succo di pera nel bicchiere. La pera è buona.
La stringa modificata
Oggi a pranzo ho mangiato una pesca. Dopo pranzo berrò un succo di pesca nel bicchiere. La pesca è buona.

La funzione PHP preg_replace() su un Array di valori

E' possibile usare la funzione PHP preg_replace() anche su un Array di valori, con la stessa facilità d'uso di una normale stringa.
Per questo esempio ho preso un Array di codici in formato misto: numeri_letterale_numeri: 201_parente_000 ed ho fatto queste prove.

Eliminare la parte numerica di codici memorizzati in un Array: in questo esempio, per brevità, mostro tre REGEX nell'unico script di cui uno solo è quello attivo. Ecco quel che fanno: per tutte viene usato il replacement ''.

  • Con $pattern = '/^([0-9_]){4}/'; tolgo la parte numerica ed il trattino basso della parte sinistra delle stringhe lasciando la parte alfabetica e numerica a destra ottenendo una cosa del genere: parente_000
  • Con $pattern = '/([_0-9]){4}$/'; tolgo la parte numerica ed il trattino basso della parte destra delle stringhe lasciando la parte numerica a sinistra e la parte alfabetica ottenendo una cosa del genere: 201_parente
  • Con $pattern = '/([_0-9]){4}/'; tolgo le porzioni numeriche ed i trattini bassi lasciando solo la parte alfabetica ottenendo il risultato mostrato qui in basso.
preg_replace_12
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<?php
$codici 
= array(
"201_parente_000",
"900_ufficio_700",
"004_fam_012",
"200_amico_124",
"600_medico_125",
"200_amico_005",
"500_conosc_000",
"600_medico_147",
"500_conosc_166",
"600_medico_124",
"201_parente_000",
"200_amico_001",
"900_ufficio_661",
"900_ufficio_875",
"600_medico_000",
"004_fam_011",
"200_amico_001"
);
//$pattern = '/^([0-9_]){4}/';
//$pattern = '/([_0-9]){4}$/';
$pattern '/([_0-9]){4}/';
$replacement '';
$array_modificato preg_replace($pattern$replacement$codici);
for (
$i 0$i count ($array_modificato); $i++) {
    echo 
$array_modificato[$i] . "<br />\n";
}
?> 
parente
ufficio
fam
amico
medico
amico
conosc
medico
conosc
medico
parente
amico
ufficio
ufficio
medico
fam
amico

Eliminare la parte alfabetica di codici memorizzati in un Array: anche in questo esempio mostro le tre possibili REGEX di cui uno solo è quello attivo. Per tutte il replacement è ''.

  • Con $pattern = '/[A-Za-z_]/'; elimino la parte alfabetica ed i trattini bassi lasciando entrambe le porzioni numeriche ottenendo come risultato una cosa del genere: 201000
  • Con $pattern = '/^[0-9]{3}_[A-Za-z]{3,15}_/'; elimino la parte numerica sinistra e la parte alfabetica con i trattini bassi lasciando la sola parte numerica destra: 000
  • Con $pattern = '/[A-Za-z_]{3,15}_[0-9]{3}$/'; elimino la parte alfabetica e la parte numerica destra conpresi i trattini bassi lasciando la parte numerica sinistra: 201
preg_replace_12_a
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<?php
$codici 
= array(
"201_parente_000",
"900_ufficio_700",
"004_fam_012",
"200_amico_124",
"600_medico_125",
"200_amico_005",
"500_conosc_000",
"600_medico_147",
"500_conosc_166",
"600_medico_124",
"201_parente_000",
"200_amico_001",
"900_ufficio_661",
"900_ufficio_875",
"600_medico_000",
"004_fam_011",
"200_amico_001"
);
//$pattern = '/[A-Za-z_]/';
//$pattern = '/^[0-9]{3}_[A-Za-z]{3,15}_/';
$pattern '/[A-Za-z_]{3,15}_[0-9]{3}$/';
$replacement '';
$array_modificato preg_replace($pattern$replacement$codici);
for (
$i 0$i count ($array_modificato); $i++) {
    echo 
$array_modificato[$i] . "<br />\n";
}
?> 
201
900
004
200
600
200
500
600
500
600
201
200
900
900
600
004
200

Usare la funzione PHP preg_replace() su un Array con i gruppi

Questa soluzione forse è più pratica delle due viste in precedenza. Invece di creare delle classi di caratteri su cui lavorare vengono creati dei gruppi, in questo caso, più semplici da gestire. Questa immagine mostra i gruppi creati per uno dei codici memorizzati nell'Array.

Mostrare una parte interessata dei valori memorizzati in un Array: nel codice mostrato qui di seguito, dopo aver creato l'Array coi codici viene creato il pattern '/(.*)_(.*)_(.*)/' per creare i tre gruppi di sottostringhe. Vengono creati quattro diversi replacement di cui uno solo è quello attivo. Quelli commentati sono solo degli ulteriori esempi su cui lavorare:

  • $replacement = '$2-$3-$1'; sposta i vari gruppi
  • $replacement = '$2-$1'; visualizza solo due dei gruppi
  • $replacement = '$2'; visualizza un solo gruppo
  • $replacement = '$1'; visualizza un altro gruppo
preg_replace_14
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
<?php
$codici 
= array(
"201_parente_000",
"900_ufficio_700",
"004_fam_012",
"200_amico_124",
"600_medico_125",
"200_amico_005",
"500_conosc_000",
"600_medico_147",
"500_conosc_166",
"600_medico_124",
"201_parente_000",
"200_amico_001",
"900_ufficio_661",
"900_ufficio_875",
"600_medico_000",
"004_fam_011",
"200_amico_001"
);
$pattern '/(.*)_(.*)_(.*)/';
//$replacement = '$2-$3-$1';
$replacement '$2-$1';
//$replacement = '$2';
//$replacement = '$1';
$array_modificato preg_replace($pattern$replacement$codici);

echo 
"<table  class=\"tabella_it\">\n";
echo 
"<tr>\n";
echo 
"<th>L'Array da modificare</th>\n";
echo 
"<th>L'Array modificato</th>\n";
echo 
"</tr>\n";
echo 
"<tr>\n";
echo 
"<td>\n";
for (
$i 0$i count ($codici); $i++) {
    echo 
$codici[$i] . "<br />\n";
}
echo 
"</td>\n";
echo 
"<td>\n";
for (
$i 0$i count ($array_modificato); $i++) {
    echo 
$array_modificato[$i] . "<br />\n";
}
echo 
"</td>\n";
echo 
"</tr>\n";
echo 
"</table>\n";
?> 
L'Array da modificare L'Array modificato
201_parente_000
900_ufficio_700
004_fam_012
200_amico_124
600_medico_125
200_amico_005
500_conosc_000
600_medico_147
500_conosc_166
600_medico_124
201_parente_000
200_amico_001
900_ufficio_661
900_ufficio_875
600_medico_000
004_fam_011
200_amico_001
parente-201
ufficio-900
fam-004
amico-200
medico-600
amico-200
conosc-500
medico-600
conosc-500
medico-600
parente-201
amico-200
ufficio-900
ufficio-900
medico-600
fam-004
amico-200

Contare e limitare le sostituzioni con l'uso di Array

Anche lavorando con gli Array è possibile contare e limitare le sostituzioni da fare e quelle fatte. Tuttavia il conteggio delle sostituzioni viene applicato sul numero degli elementi memorizzati negli Array e non già sul reale numero di sostituzioni effettuate.

Sostituire alcune sottostringhe con altrettante stringhe: qui in basso viene usata la funzione PHP preg_replace() su una stringa che contiene diverse occorrenze di alcune parole. I due Array usati per replacement e pattern si riferiscono ad alcune di queste parole.
Nell'esempio non si pone alcun limite alle sostituzioni impostando a -1 l'argomento limit della funzione PHP preg_replace() e si può facilmente verificare il numero di sostituzioni effettuate.

preg_replace_9
1
2
3
4
5
6
7
8
9
10
11
12
<?php
$stringa 
"Si può abitare in una casa di pietra, in casa di cemento, in una casa di legno oppure in una casa di mattoni.";
$pattern = array('/casa/''/di/''/una/');
$replacement = array('abitazione''costrita con''');
$stringa_modificata preg_replace($pattern$replacement$stringa, -1$count);
//    ================= Secondo esempio =========================
echo "La stringa da modificare<br />\n";
echo 
$stringa "<br />\n";
echo 
"La stringa modificata<br />\n";
echo 
$stringa_modificata "<br />\n";
echo 
"Effettuate " $count " sostituzioni<br />\n";
?> 
La stringa da modificare
Si può abitare in una casa di pietra, in casa di cemento, in una casa di legno oppure in una casa di mattoni.
La stringa modificata
Si può abitare in abitazione costrita con pietra, in abitazione costrita con cemento, in abitazione costrita con legno oppure in abitazione costrita con mattoni.
Effettuate 11 sostituzioni

Sostituire solo una volta alcune sottostringhe con altrettante stringhe: nell'esempio che segue, si è imposto un limite alle sostituzioni e, leggendo il numero delle sostituzioni effettuate, sembra che questo limite non sia stato rispettato. Invece è stato rispettato. Ogni occorrenza descritta in replacement e pattern è stata usata, ove possibile, per il numero indicato in limit.

preg_replace_10
1
2
3
4
5
6
7
8
9
10
11
12
<?php
$stringa 
"Si può abitare in una casa di pietra, in casa di cemento, in una casa di legno oppure in una casa di mattoni.";
$pattern = array('/casa/''/di/''/una/');
$replacement = array('abitazione''costrita con''');
$stringa_modificata preg_replace($pattern$replacement$stringa1$count);
//    ================= Secondo esempio =========================
echo "La stringa da modificare<br />\n";
echo 
$stringa "<br />\n";
echo 
"La stringa modificata<br />\n";
echo 
$stringa_modificata "<br />\n";
echo 
"Effettuate " $count " sostituzioni<br />\n";
?> 
La stringa da modificare
Si può abitare in una casa di pietra, in casa di cemento, in una casa di legno oppure in una casa di mattoni.
La stringa modificata
Si può abitare in abitazione costrita con pietra, in casa di cemento, in una casa di legno oppure in una casa di mattoni.
Effettuate 3 sostituzioni

 

 



settore tecnico il sito di lorettabweb il Forum di sostegno
il forum il forum il forum