PHP è uno dei linguaggi di pro­gram­ma­zio­ne più comuni per la pro­gram­ma­zio­ne lato server. Con il passare del tempo, è diventato una parte in­di­spen­sa­bi­le di buona parte dei moderni siti web e delle tec­no­lo­gie internet. Ma imparare questo lin­guag­gio può essere una grande sfida per chi è alle prime armi. Con questo tutorial su PHP ti mostriamo le basi di questo popolare lin­guag­gio di pro­gram­ma­zio­ne, compresi i suoi operatori, i cicli e le funzioni più im­por­tan­ti.

Riassunto

  • Per eseguire gli esempi ti serve un server web con in­ter­pre­te PHP, ad esempio tramite XAMPP, il server integrato di PHP o Docker.
  • Le basi di PHP com­pren­do­no sintassi, echo, variabili, ti­piz­za­zio­ne rigorosa, operatori di con­ca­te­na­zio­ne e calcolo con le variabili.
  • Con le su­per­glo­ba­li $_GET e $_POST trasmetti i dati, con if, match e i cicli controlli il flusso del programma.
  • Altri capitoli mostrano le ope­ra­zio­ni sui file, la pro­gram­ma­zio­ne orientata agli oggetti e il codice pulito con Composer e namespace.
  • Per con­clu­de­re, il tutorial presenta un esempio PDO per i database e misure di pro­te­zio­ne come i prepared statement, l’escaping dell’output e l’hashing delle password.

Tutorial su PHP: una guida completa

Il nostro tutorial si rivolge prin­ci­pal­men­te a chi è alle prime armi. Per alcuni esempi, tuttavia, è utile avere una co­no­scen­za di base dello sviluppo web moderno e del lin­guag­gio HTML. I requisiti per ri­pro­dur­re gli esempi il­lu­stra­ti in questo articolo sul tuo computer sono i seguenti:

  • Un server web con in­ter­pre­te PHP
  • Avere in­stal­la­to PHP
  • Un browser web
  • Un editor di testo

XAMPP

Come server, con­si­glia­mo l’ambiente di test locale XAMPP, fornito gra­tui­ta­men­te da Apache Friends per i sistemi operativi Windows, Linux e macOS. XAMPP è un server di test puro. Il pacchetto software offre la pos­si­bi­li­tà di con­fi­gu­ra­re un ambiente di test completo per script, pagine HTML e fogli di stile in po­chis­si­mo tempo. Tuttavia, il fun­zio­na­men­to sicuro come server web su internet non è garantito. Le istru­zio­ni det­ta­glia­te per l’in­stal­la­zio­ne sono di­spo­ni­bi­li nel nostro tutorial su XAMPP.

Web Hosting
Miglior Hosting per il tuo sito web o negozio
  • Di­spo­ni­bi­li­tà garantita al 99,99%
  • Dominio, SSL ed e-mail inclusi
  • As­si­sten­za 24/7 in lingua italiana

Server integrato PHP

A partire dalla versione 5.4, PHP include un server di sviluppo integrato, par­ti­co­lar­men­te adatto per test semplici e per l’ap­pren­di­men­to. Questo server integrato non richiede alcun software server ag­giun­ti­vo come Apache o NGINX. L’unico requisito è avere in­stal­la­ta una versione di PHP sul tuo sistema. Suc­ces­si­va­men­te puoi avviare il server di­ret­ta­men­te dalla riga di comando nella directory del progetto:

php -S localhost:8000
bash

PHP rende quindi di­spo­ni­bi­li i file nella cartella corrente all’indirizzo http://localhost:8000 nel browser web. Il server integrato è adatto so­prat­tut­to per i primi espe­ri­men­ti con PHP, piccoli script di test o per ri­co­strui­re ra­pi­da­men­te esempi di codice.

Docker e Docker Compose

Un’al­ter­na­ti­va un po’ più avanzata è l’utilizzo di Docker. Docker consente di in­cap­su­la­re gli ambienti di sviluppo nei co­sid­det­ti container. In questo modo è possibile con­fi­gu­ra­re server web, PHP e database esat­ta­men­te come verranno eseguiti in seguito nell’ambiente di pro­du­zio­ne. Per i progetti PHP si utilizza spesso Docker-Compose, per avviare più servizi con­tem­po­ra­nea­men­te. L’intera con­fi­gu­ra­zio­ne viene definita in un file (“docker-compose.yml”) e può essere avviata con un unico comando.

Basi di PHP: la sintassi del lin­guag­gio di scripting

Una volta con­fi­gu­ra­to il server web locale, ad esempio uti­liz­zan­do XAMPP, è opportuno ve­ri­fi­ca­re se PHP è stato in­stal­la­to cor­ret­ta­men­te ed è pronto a eseguire gli script. Gli script sono programmi che non vengono pre­ven­ti­va­men­te compilati in codice binario, ma vengono eseguiti da un in­ter­pre­te. Aprendo il tuo editor di testo preferito, puoi creare il seguente script PHP:

<?php
phpinfo();
?>
php

Gli script PHP sono sempre strut­tu­ra­ti secondo lo stesso schema. Il tag PHP di apertura <?php indica che si sta avviando un ambiente di script. A questo segue il codice PHP vero e proprio, sotto forma di istru­zio­ni. Nell’esempio, si tratta dell’istru­zio­ne alla funzione phpinfo(). La maggior parte delle funzioni PHP richiede uno o più parametri racchiuso tra parentesi tonde; per phpinfo() questi sono opzionali. Ogni istru­zio­ne termina con un punto e virgola (;). Per chiudere l’ambiente di script, si usa il tag PHP di chiusura: ?>, che è fa­col­ta­ti­vo per i file PHP puri.

Salva il file di testo con il nome “test” in formato .php (script PHP) e avvia il tuo server web. Se stai uti­liz­zan­do l’ambiente di test XAMPP, salva “test.php” nella directory XAMPP sotto “htdocs” (C:\xampp\htdocs).

Immagine: Il file test.php nella cartella htdocs
Per poter eseguire il file test.php tramite XAMPP, devi po­si­zio­nar­lo nella cartella htdocs.

Ora puoi accedere al file di esempio tramite il seguente URL nel browser web: http://localhost/test.php. Se stai uti­liz­zan­do un server web diverso o una con­fi­gu­ra­zio­ne in­di­vi­dua­le del software XAMPP, seleziona l’URL in base al ri­spet­ti­vo percorso del file.

Digitando l’URL http://localhost/test.php richiedi al browser il file “test.php” dal server web. Il server HTTP Apache o il software del server web uti­liz­za­to re­cu­pe­re­rà il file nella giusta directory. L’esten­sio­ne .php informa che il file contiene codice PHP. A questo punto entra in funzione l’in­ter­pre­te PHP integrato nel server web. Esso esamina il documento e incontra il tag PHP di apertura <?php, il quale segna l’inizio del codice PHP. L’in­ter­pre­te è in grado di eseguire il codice PHP e di generare l’output HTML che viene inviato dal server web al browser web.

N.B.

La funzione phpinfo() è la forma ab­bre­via­ta del valore standard phpinfo(INFO_ALL). Questa re­sti­tui­sce in­for­ma­zio­ni det­ta­glia­te sulla con­fi­gu­ra­zio­ne PHP del tuo server web. Se non viene trovata alcuna versione di PHP, il browser web mostra un messaggio di errore oppure invia al browser il codice PHP senza in­ter­pre­tar­lo.

“Hello World!”: come creare un output di testo tramite echo

Una volta che l’in­stal­la­zio­ne di PHP è andata a buon fine, è il momento di scrivere il primo script. L’istru­zio­ne PHP echo si presta bene a questo scopo. Di­ver­sa­men­te da phpinfo(), echo non è una funzione. Si tratta piuttosto di un costrutto lin­gui­sti­co che consente di produrre una stringa suc­ces­si­va come testo.

De­fi­ni­zio­ne

I costrutti lin­gui­sti­ci sono istru­zio­ni uti­liz­za­te in PHP per con­trol­la­re il processo di pro­gram­ma­zio­ne. Oltre a echo, i costrutti lin­gui­sti­ci includono istru­zio­ni come if, for, do, include, return, exit o die. A dif­fe­ren­za delle funzioni, quindi, in questo caso non sono ne­ces­sa­rie le parentesi.

Crea un nuovo file PHP per il tuo primo script e scrivici il seguente codice:

<?php
echo 'Hello World!';
php

Il tag di apertura <?php apre un ambiente di script. Seguono il costrutto lin­gui­sti­co echo e la stringa Hello World! racchiusa in vir­go­let­te singole. Fai at­ten­zio­ne al punto e virgola dopo l’istru­zio­ne. Al posto di “Hello World!” puoi usare qualsiasi testo. Poiché si tratta di un file PHP puro, abbiamo ri­nun­cia­to al tag PHP di chiusura.

Consiglio

Il tag PHP di chiusura ?> non deve essere uti­liz­za­to nei file che con­ten­go­no solo PHP. In questo modo si possono evitare righe vuote ac­ci­den­ta­li o caratteri in­vi­si­bi­li alla fine del file, che po­treb­be­ro causare messaggi di errore come “Headers already sent”.

Salva lo script come “hello.php” nella cartella “htdocs” del server web e apri il file tramite l’URL http://localhost/hello.php sul browser web. Se il codice è stato tra­sfe­ri­to cor­ret­ta­men­te, nella finestra del browser dovrebbe apparire la stringa uti­liz­za­ta:

Immagine: Output del testo con la costruzione linguistica echo
Nel browser vi­sua­liz­zi l’output “Hello World”.

Qualsiasi testo emesso con echo può essere con­tras­se­gna­to con tag HTML, se ne­ces­sa­rio. Questi tag vengono poi in­ter­pre­ta­ti dal browser web in base alle spe­ci­fi­che HTML. Fai una prova, ad esempio con il seguente script:

<?php
echo '<h1>Hello World!</h1>
<p>This is my first PHP page.</p>';
php

Quando viene vi­sua­liz­za­to nel browser web, il risultato dell’ese­cu­zio­ne dello script appare come segue.

Immagine: Risultato dell’esecuzione di uno script con tag HTML
L’output può essere for­mat­ta­to con tag HTML nello script PHP.

La stringa “Hello World!” compresa nei tag <h1> viene in­ter­pre­ta­ta dal browser web come primo titolo. È seguita da un’in­ter­ru­zio­ne di riga au­to­ma­ti­ca e dal paragrafo di testo <p>.

A seconda delle esigenze, echo può essere usato con vir­go­let­te singole (') o doppie ("). Se vogliamo emettere solo testo, non fa alcuna dif­fe­ren­za la scelta delle vir­go­let­te. Ma le cose cambiano quando entrano in gioco le variabili PHP.

Le variabili

Il costrutto lin­gui­sti­co echo è molto più di un semplice output di testo. Infatti, può essere im­ple­men­ta­to ef­fi­ca­ce­men­te anche senza PHP, su una base di HTML. Il vero valore aggiunto di echo si basa sul fatto che l’istru­zio­ne consente di generare testo di­na­mi­ca­men­te con l’aiuto di variabili.

Le variabili si pre­sen­ta­no ad esempio nella forma seguente: $example.

Ciascuna variabile è co­sti­tui­ta dal simbolo del dollaro ($) seguito dal nome della variabile. Le variabili sono uti­liz­za­te negli script PHP per includere dati esterni nelle pagine web. Possono essere valori di vario tipo, da semplici numeri e stringhe a testi interi o strutture di documenti HTML.

Il PHP distingue otto tipi di variabili:

Tipo di variabile De­scri­zio­ne
String Una stringa è un insieme di caratteri. Può essere una parola, una frase, un testo o l’intero codice HTML di una pagina web.
Integer Un integer è un numero intero senza cifre decimali. Può essere positivo o negativo.
Float Un float è un numero in virgola mobile, cioè un valore numerico con cifre decimali. Nei linguaggi di pro­gram­ma­zio­ne, la virgola decimale si scrive come punto (.). La pre­ci­sio­ne è di circa 14 cifre si­gni­fi­ca­ti­ve; vengono con­teg­gia­te tutte le cifre, non solo quelle dopo la virgola.
Boolean Le variabili booleane sono il risultato di un’ope­ra­zio­ne logica e pre­sen­ta­no solo due valori: TRUE (vero) e FALSE (falso). Questo tipo di variabile viene uti­liz­za­to, ad esempio, per lavorare con le con­di­zio­ni.
Array Un array è una variabile che può contenere diversi elementi. È quindi un rag­grup­pa­men­to di diversi dati strut­tu­ra­ti in modo simile che sono stati combinati in un array.
Object Il tipo di variabile object consente a chi programma di definire i propri tipi di dati. Viene uti­liz­za­to nella pro­gram­ma­zio­ne orientata agli oggetti. Nel nostro tutorial PHP per chi è alle prime armi, le variabili di tipo object sono state escluse.
NULL Il valore NULL rap­pre­sen­ta una variabile senza valore, l’unico valore possibile per le variabili di tipo NULL.
Resource Resource è una variabile speciale che contiene un ri­fe­ri­men­to a risorse esterne, ad esempio un file aperto, una con­nes­sio­ne al database o un socket. Le risorse sono gestite di­ret­ta­men­te da PHP. Nel nostro tutorial PHP tra­la­scia­mo queste variabili.

La gestione cen­tra­liz­za­ta dei contenuti viene so­li­ta­men­te ef­fet­tua­ta con l’aiuto di sistemi di database. È tuttavia possibile definire i valori delle variabili anche di­ret­ta­men­te nello script. Questo tipo di as­se­gna­zio­ne avviene secondo il seguente schema:

$example = "value";
php

Il ca­rat­te­ri­sti­co simbolo del dollaro è seguito dal nome della variabile (in questo caso example). A ciò si aggiunge il simbolo di uguale (=) con un valore racchiuso tra doppie vir­go­let­te. I valori delle variabili di tipo integer e float sono indicati senza vir­go­let­te (ad esempio, $example = 24; o $example = 2.7;).

PHP offre la libertà di nominare le variabili come meglio si crede. Tuttavia, si applicano le seguenti re­stri­zio­ni:

  • Ogni variabile deve iniziare con il simbolo del dollaro.
  • Il nome di una variabile è una suc­ces­sio­ne di caratteri a pia­ci­men­to composta da lettere, numeri e trattini bassi (ad esempio $example_1).
  • Il nome di una variabile valido inizia sempre con una lettera o un trattino basso ($example1 o $_example), mai con una cifra (errato: $1example).
  • Il PHP è case sensitive. Il lin­guag­gio di scripting fa quindi di­stin­zio­ne tra lettere maiuscole e minuscole ($example ≠ $Example).
  • Il nome di una variabile non deve contenere spazi o in­ter­ru­zio­ni di riga (errato: $example 1).
  • Le stringhe riservate da PHP per altri scopi non possono essere uti­liz­za­te come variabili definite dall’utente (ad esempio, $this).

Ap­pro­fon­dia­mo quest’ultimo punto con un esempio:

<?php
$author = "John Doe";
echo "<h1>Hello World!</h1>
<p>This dynamic web page was created by $author.</p>";
php

Il tag PHP di apertura è seguito dalla de­fi­ni­zio­ne della variabile: per $author deve essere uti­liz­za­to il valore “John Doe”. Quando lo script viene eseguito, la variabile $author viene so­sti­tui­ta dal valore “John Doe” ogni volta che viene men­zio­na­ta nell’ambiente di script. Nell’immagine seguente vediamo come si pre­sen­te­reb­be il browser web.

Immagine: Creazione dinamica di testo con variabili
Le variabili sono una specie di se­gna­po­sto e con­sen­to­no la creazione dinamica dei testi.

Se c’è un errore e la pagina web non proviene da John Doe, ma dal suo collega Max Mu­ster­mann, per risolvere il problema è suf­fi­cien­te mo­di­fi­ca­re la variabile con il nome $author. Ciò si rivela par­ti­co­lar­men­te efficace quando una variabile ricorre più volte all’interno di uno script. In tal caso, la cor­re­zio­ne deve essere ef­fet­tua­ta solo in un singolo punto: dove viene definito il valore della variabile.

I vantaggi di questo concetto di design sono palesi: se alcuni elementi del sito web (ad esempio nel footer) vengono mo­di­fi­ca­ti, non occorre apportare le modifiche ma­nual­men­te su ogni singola sot­to­pa­gi­na del progetto web. Piuttosto, basterà ag­gior­na­re la voce cor­ri­spon­den­te nel database. Così, la revisione viene applicata au­to­ma­ti­ca­men­te a tutte le pagine web che includono i dati cor­ri­spon­den­ti come variabili.

Se una variabile viene definita più volte all’interno di uno script, la nuova de­fi­ni­zio­ne so­vra­scri­ve la pre­ce­den­te. Un elemento echo suc­ces­si­vo re­sti­tui­sce sempre il valore corrente di una variabile.

<?php
$author = "John Doe";
echo "<h1>Hello World!</h1>
<p>This dynamic web page was created by $author.</p>";
$author = "Max Mustermann";
echo " <p>Supported by $author.</p>";
php

Nell’esempio di codice, il valore “John Doe” viene prima assegnato alla variabile $author e poi so­sti­tui­to con il valore “Max Mu­ster­mann”.

Immagine: La sovrascrizione delle variabili
Se una variabile con lo stesso nome viene definita più volte, ogni nuova de­fi­ni­zio­ne so­vra­scri­ve la pre­ce­den­te.

Passiamo ora alle vir­go­let­te. A dif­fe­ren­za delle stringhe, le variabili singole non devono essere racchiuse tra vir­go­let­te:

<?php
$author = "John Doe";
echo $author;
php

Questo è vero a meno che la variabile non debba essere uti­liz­za­ta all’interno di una stringa. In tal caso, infatti, vanno usate le doppie vir­go­let­te (“), che segnalano all’in­ter­pre­te PHP di cercare nella stringa le variabili che po­treb­be­ro dover essere so­sti­tui­te dai valori a esse associati. Le stringhe racchiuse tra vir­go­let­te singole (’) vengono in­ter­pre­ta­te e rese come in­for­ma­zio­ni di testo semplice, anche se si tratta di variabili.

<?php
$author = "John Doe";
echo '<h1>Hello World!</h1>
<p>This dynamic web page was created by $author.</p>';
php

La variabile in questo caso quindi non viene in­ter­pre­ta­ta, ma sem­pli­ce­men­te re­sti­tui­ta come testo.

Immagine: Output di testo puro in caso di virgolette singole
Se una stringa è racchiusa tra vir­go­let­te singole e al suo interno compare il nome di una variabile, questa non viene in­ter­pre­ta­ta.
N.B.

Forse ti starai chiedendo cosa succede se ometti del tutto le vir­go­let­te? In questo caso, PHP segnala un errore sin­tat­ti­co.

Ti­piz­za­zio­ne rigorosa con declare(strict_types=1)

Per im­po­sta­zio­ne pre­de­fi­ni­ta PHP cerca di con­ver­ti­re au­to­ma­ti­ca­men­te tra loro tipi di dati diversi. In questo modo ci si de­streg­gia tra diversi tipi e può succedere che i valori errati vengano elaborati ul­te­rior­men­te senza essere notati. Con la direttiva declare(strict_types=1); è possibile di­sat­ti­va­re in modo mirato questo com­por­ta­men­to. PHP controlla quindi in modo rigoroso, durante le chiamate di funzione, se gli argomenti passati e i valori di ritorno cor­ri­spon­do­no ai tipi di variabile di­chia­ra­ti. La direttiva deve trovarsi all’inizio di un file PHP e ha effetto solo su tale file:

<?php
declare(strict_types=1);
function add(int $a, int $b): int
{
return $a + $b;
}
echo add(2, 3); 
echo add("2", 3);
php

Nell’esempio, una funzione PHP chiamata add() accetta esclu­si­va­men­te valori interi. Mentre la chiamata con 2 e 3 funziona senza problemi, la seconda chiamata genera un errore, perché la stringa "2" non viene con­ver­ti­ta au­to­ma­ti­ca­men­te in un numero intero. Grazie alla ti­piz­za­zio­ne rigorosa, problemi di questo tipo vengono in­di­vi­dua­ti pre­co­ce­men­te, il che migliora sen­si­bil­men­te la ma­nu­te­ni­bi­li­tà e l’af­fi­da­bi­li­tà del codice PHP.

Messaggi di errore e ma­sche­ra­men­to

Se si ve­ri­fi­ca­no errori sin­tat­ti­ci, il codice PHP non risulta valido per cui l’in­ter­pre­te PHP emette un messaggio di errore. Può capitare, ad esempio, quando l’istru­zio­ne echo viene uti­liz­za­ta con una stringa senza vir­go­let­te:

<?php
echo Hello World!;
php

Nella maggior parte dei casi, i messaggi di errore con­ten­go­no in­for­ma­zio­ni sul punto in cui si è ve­ri­fi­ca­to l’errore e for­ni­sco­no quindi im­por­tan­ti in­di­ca­zio­ni per la sua ri­so­lu­zio­ne. Puoi comunque vi­sua­liz­za­re i messaggi nel log di XAMPP in C:\xampp\logs\php_error_log.

Immagine: Nel log trovi un messaggio di errore: parse error
Gli errori vengono sempre vi­sua­liz­za­ti nel log di XAMPP.

Nell’esempio presente, è stato rilevato un errore nella riga 2 del codice del programma, proprio dove abbiamo omesso le vir­go­let­te a scopo di­mo­stra­ti­vo.

Si ve­ri­fi­ca­no errori sin­tat­ti­ci anche quando vuoi vi­sua­liz­za­re come testo caratteri che in PHP sono associati a un compito specifico. Un esempio è il segno di apice (’). I caratteri di questo tipo possono essere emessi come testo in PHP solo se fai capire all’in­ter­pre­te che il carattere è stato svin­co­la­to dalla sua funzione ori­gi­na­ria. Nel caso degli apici semplici hai a di­spo­si­zio­ne due pos­si­bi­li­tà: puoi rac­chiu­de­re una stringa con apici semplici tra vir­go­let­te doppie oppure ma­sche­rar­li an­te­po­nen­do un backslash (ope­ra­zio­ne detta anche “escape”):

<?php
echo '\'Hello World!\' ';
php
Immagine: Usare la barra rovesciata come carattere di mascheramento
Il backslash (la barra ro­ve­scia­ta) viene uti­liz­za­to in PHP come carattere di escape.

È possibile anche la com­bi­na­zio­ne di vir­go­let­te singole e doppie:

<?php
echo " 'Hello World!' ";
php

Tuttavia, non è ammessa la seguente scrittura:

<?php
echo ' 'Hello World!' ';
php

Gli spazi tra le vir­go­let­te sono stati inseriti negli esempi per fa­ci­li­ta­re la lettura.

Operatori di con­ca­te­na­zio­ne

Se in uno script PHP vogliamo produrre con­tem­po­ra­nea­men­te diverse variabili, possiamo im­ple­men­ta­re questo metodo come abbiamo imparato finora:

<?php
$author1 = "John Doe";
$author2 = "Max Mustermann";
echo "<h1>Hello World!</h1>
<p>This dynamic web page was created by $author1 and $author2.</p>";
php

È suf­fi­cien­te scrivere entrambe le variabili insieme al resto del testo da produrre nella stringa racchiusa tra doppie vir­go­let­te. PHP riconosce au­to­ma­ti­ca­men­te le variabili dal simbolo del dollaro ($) e inserisce i valori cor­ri­spon­den­ti.

Immagine: Output di testo con due variabili
Con due variabili puoi teo­ri­ca­men­te procedere esat­ta­men­te come con una sola.

Tra le persone che si occupano di pro­gram­ma­zio­ne, tuttavia, una procedura di questo tipo è con­si­de­ra­ta un lavoro poco pulito. Il dogma è che le variabili non devono far parte della stringa. Una delle ragioni è che molti linguaggi di pro­gram­ma­zio­ne pre­scri­vo­no questa se­pa­ra­zio­ne. Ma so­prat­tut­to, anche PHP richiede la se­pa­ra­zio­ne tra stringa e variabile quando si lavora con funzioni o variabili più complesse. Per questo motivo, è con­si­glia­bi­le im­ple­men­ta­re questa se­pa­ra­zio­ne in modo coerente anche nell’output di testo semplice, anche se in questo caso non sarebbe stret­ta­men­te ne­ces­sa­rio.

Se lavoriamo con le variabili, dobbiamo sempre avere a che fare con diversi elementi che devono essere collegati tra loro per l’output. In PHP, a questo scopo si utilizza l’operatore di con­ca­te­na­zio­ne (.).

Se è stato pro­gram­ma­to in modo “pulito”, il codice dell’esempio pre­ce­den­te dovrebbe essere simile a questo:

<?php
$author1 = "John Doe";
$author2 = "Max Mustermann";
echo '<h1>Hello World!</h1>
<p>This dynamic web page was created by ' . $author1 . ' and ' . $author2 . '.</p>';
php

Si tratta quindi di tre stringhe e due variabili che vengono con­ca­te­na­te per formare una stringa.

String1 Variable1 String2 Variable2 String3
’<h1>Hello World!</h1><p>This dynamic web page was created by ’ . $author1 . ’ and ’ . $author2 . ‘.</p>’

Si noti che l’operatore di con­ca­te­na­zio­ne unisce stringhe o variabili senza spazi. Se desideri ag­giun­ge­re uno spazio, devi inserirlo all’interno delle vir­go­let­te nella stringa, come nell’esempio.

Immagine: Collegamento di stringhe e variabili con operatori di concatenazione
È una buona pratica di pro­gram­ma­zio­ne con­ca­te­na­re più elementi con l’operatore di con­ca­te­na­zio­ne.

L’operatore di con­ca­te­na­zio­ne viene uti­liz­za­to nella pro­gram­ma­zio­ne non solo per collegare stringhe e variabili per l’output di testo, ma anche per estendere le variabili. L’esempio seguente mostra come funziona:

<?php
$example = 'Hello ';
$example .= 'World';
echo $example;
php

Per estendere il valore di una variabile, de­fi­ni­sci­la nuo­va­men­te, ma inserisci l’operatore di con­ca­te­na­zio­ne prima del segno di uguale. Si tratta della consueta forma ab­bre­via­ta per $example = $example . 'World'.

PHP ag­giun­ge­rà il nuovo valore a quello definito in pre­ce­den­za. Se desideri uno spazio tra i due valori, scrivilo alla fine della prima stringa, come nell’esempio.

Immagine: Estensione del valore di una variabile
L’operatore di con­ca­te­na­zio­ne viene uti­liz­za­to anche per con­ca­te­na­re di­ret­ta­men­te le variabili.

Come in­cor­po­ra­re PHP in HTML

So­stan­zial­men­te, l’in­ter­pre­te PHP è in­te­res­sa­to solo al codice che si trova tra un tag PHP di apertura e uno di chiusura (anche se quest’ultimo è opzionale nel caso di PHP puro):

<?php [Solo questa area viene analizzata dall'interprete PHP] ?>

Tutte le altre sezioni del documento vengono ignorate dall’in­ter­pre­te e passate al server web così come sono. Il codice PHP può quindi essere integrato nei documenti HTML a piacere, ad esempio per creare un template per un sistema di gestione dei contenuti. È im­por­tan­te ac­cer­tar­si che i documenti HTML con­te­nen­ti codice PHP siano salvati come file PHP. Al­tri­men­ti, il documento non verrà pre­pro­ces­sa­to dall’in­ter­pre­te PHP, ma con­se­gna­to di­ret­ta­men­te al browser web, con il risultato che il codice del programma apparirà sul sito web sotto forma di testo.

Si può quindi pensare all’in­ter­pre­te PHP come al collega pigro del server web, che lavora solo quando gli viene chiesto espli­ci­ta­men­te di farlo, ad esempio tramite un tag PHP di apertura.

Se vogliamo combinare HTML e PHP, scriviamo la nostra pagina HTML come di consueto secondo la struttura classica del documento e sal­via­mo­la con l’esten­sio­ne .php:

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>My first PHP page</title>
</head>
<body>
<h1>Hello World</h1>
<p>What is the current time and date?</p>
</body>
</html>
html

Ag­giun­gia­mo ora uno script PHP al documento HTML. As­si­cu­ra­ti che l’intero codice del programma sia all’interno dei tag PHP.

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>My first PHP page</title>
</head>
<body>
<h1>Hello World</h1>
<p>What is the current time and date?</p>
<p>Your current time and date is:
<?php
echo date("d.m.Y H:i:s");
?>.</p>
</body>
</html>
html

Nell’esempio, abbiamo combinato il costrutto lin­gui­sti­co echo con la funzione PHP date() per mostrare la data e l’ora corrente come testo sul lato server. Il parametro della funzione specifica il formato de­si­de­ra­to sotto forma di stringa:

"d.m.Y H:i:s" (day.month.year hour:minute:second)

Se un file di questo tipo viene richiesto da un browser web, l’in­ter­pre­te PHP esegue prima lo script e scrive l’ora corrente come testo nel documento HTML. Questo viene poi con­se­gna­to dal server web e vi­sua­liz­za­to come pagina web nel browser.

Immagine: Integrazione di PHP in HTML
Puoi in­cor­po­ra­re funzioni PHP nel tuo codice HTML.

La funzione di commento di PHP

Come il codice HTML, anche PHP può essere com­men­ta­to a piacere. I commenti nel codice sorgente vengono ignorati dall’in­ter­pre­te PHP, a con­di­zio­ne che siano stati marcati ri­spet­tan­do la sintassi. Il lin­guag­gio di scripting fornisce tre diverse al­ter­na­ti­ve a questo scopo.

Se desideri con­tras­se­gna­re un’intera riga come commento e quindi esclu­der­la dall’in­ter­pre­ta­zio­ne, puoi servirti dell’hashtag (#) o di due barre oblique con­se­cu­ti­ve. Nell’esempio di codice seguente sono state uti­liz­za­te entrambe le opzioni:

<?php
## This is a single line comment
echo '<h1>Hello World!</h1>
<p>This is my first PHP page.</p>';
// This is also a single-line comment!
php

Gli editor di testo o le IDE con evi­den­zia­zio­ne della sintassi mettono in risalto i commenti con colori dif­fe­ren­ti. I passaggi di testo con­tras­se­gna­ti come commento nell’ambiente di script non arrivano affatto al browser web, a dif­fe­ren­za dei commenti HTML, perché vengono già ignorati durante l’ese­cu­zio­ne dello script dall’in­ter­pre­te PHP.

Inoltre, è possibile inserire commenti che si estendono su più righe. A tale scopo, con­tras­se­gna l’inizio di una sezione di commento con una barra obliqua seguita da un asterisco e la fine con un asterisco seguito da una barra obliqua.

<?php
/*
This is a multiple-lines comment block
that spans over multiple
lines
*/
echo '<h1>Hello World!</h1>
<p>This is my first PHP page.</p>';
php

Anche i commenti con­tras­se­gna­ti in questo modo non vengono presi in con­si­de­ra­zio­ne dall’in­ter­pre­te e quindi non compaiono sul sito web.

Immagine: Esempio di commento su più righe
Come puoi vedere, i commenti non vengono vi­sua­liz­za­ti.

Chi programma ricorre ai commenti per strut­tu­ra­re il codice sorgente dei propri script, lasciare appunti per una suc­ces­si­va modifica o ag­giun­ge­re in­for­ma­zio­ni interne alla creazione, come l’autrice o l’autore e la data. I commenti sono fa­col­ta­ti­vi e do­vreb­be­ro essere uti­liz­za­ti con par­si­mo­nia per garantire una buona leg­gi­bi­li­tà del codice sorgente.

Calcolo con le variabili

In questo tutorial dedicato al lin­guag­gio PHP abbiamo già in­con­tra­to le variabili. A queste sono stati assegnati prin­ci­pal­men­te valori string (cioè stringhe di caratteri). Ora ci oc­cu­pe­re­mo di variabili che rap­pre­sen­ta­no numeri interi (integer) o numeri in virgola mobile (float).

Se le variabili me­mo­riz­za­no valori numerici, PHP offre la pos­si­bi­li­tà di eseguire calcoli con esse. Co­min­cia­mo con la semplice addizione di due numeri interi:

<?php
$number1 = 237;
$number2 = 148;
$result = $number1 + $number2;
echo "result: " . $result;
php

Per prima cosa as­se­gnia­mo i numeri interi 237 e 148 alle variabili $number1 e $number2 e poi definiamo una variabile $result. Questa variabile ha lo scopo di me­mo­riz­za­re la somma delle due variabili. Per farlo, ci serviamo dell’**operatore arit­me­ti­co + **(più). Infine, il risultato dell’addizione viene vi­sua­liz­za­to come testo uti­liz­zan­do il costrutto lin­gui­sti­co echo. Non è ne­ces­sa­rio usare le vir­go­let­te quando si assegnano valori numerici alle variabili.

Immagine: Addizione di numeri interi con l’aiuto di uno script PHP
Puoi eseguire calcoli con variabili numeriche esat­ta­men­te come fai con i numeri.

Il seguente esempio di codice mostra una selezione di calcoli ma­te­ma­ti­ci ef­fet­tua­bi­li lato server con PHP. Gli operatori PHP uti­liz­za­ti cor­ri­spon­do­no per lo più ai simboli ma­te­ma­ti­ci stan­dar­diz­za­ti.

Operatore arit­me­ti­co Ope­ra­zio­ne Risultato
$number1 + $number2 Addizione Somma di $number1 e $number2
$number1 - $number2 Sot­tra­zio­ne Dif­fe­ren­za di $number1 e $number2
$number1 * $number2 Mol­ti­pli­ca­zio­ne Prodotto di $number1 e $number2
$number1 / $number2 Divisione Quoziente di $number1 e $number2
$number1 ** $number2 Potenza $number1 elevato alla potenza di $number2
<?php
$number1 = 10;
$number2 = 5;
$addition = $number1 + $number2; //Addition
$subtraction = $number1 - $number2; //Subtraction
$multiplication = $number1 * $number2; //Multiplication
$division = $number1 / $number2; //Division
$exponentiation = $number1 ** $number2; //Exponentiation

echo "Result of addition: " . $addition ."<br />";
echo "Result of subtraction: " . $subtraction . "<br />";
echo "Result of multiplication: " . $multiplication . "<br />";
echo "Result of division: " . $division . "<br />";
echo "5th power of 10 (10^5): " . $exponentiation . "<br />";
echo "Square root of 81: " . sqrt(81) . "<br />";
php

L’output è il seguente:

Immagine: Calcolo con le variabili
Puoi eseguire le normali ope­ra­zio­ni arit­me­ti­che in PHP anche con variabili numeriche.

Per i calcoli complessi, è possibile combinare le varie ope­ra­zio­ni arit­me­ti­che in un unico script:

<?php
$number1 = 10;
$number2 = 5;
$result = 2 * $number1 + 5 * $number2 - 3 * sqrt(81);
echo "Result: " . $result;
php

L’in­ter­pre­te PHP determina i valori delle variabili ed esegue il calcolo:

2 * 10 + 5 * 5 - 3 * √81 = 20 + 25 - 27 = 18

La funzione sqrt() calcola la radice quadrata del parametro tra parentesi. Vale la clas­si­fi­ca­zio­ne standard degli operatori ma­te­ma­ti­ci: il punto precede il trattino. L’istru­zio­ne echo produce il risultato come stringa per il browser web.

In PHP, anche i termini tra parentesi sono in­ter­pre­ta­ti per primi. Questa volta lavoriamo con numeri in virgola mobile:

<?php
$number1 = 2.5;
$number2 = 3.7;
$result = 2 * ($number1 + 5) * ($number2 - 3) * sqrt(81);
echo "Result: " . $result;
php
Immagine: Calcolo con numeri in virgola mobile e termini tra parentesi
I calcoli fun­zio­na­no anche con numeri in virgola mobile.

Come tutti i comuni linguaggi di pro­gram­ma­zio­ne, anche PHP supporta gli operatori per in­cre­men­ta­re o de­cre­men­ta­re i valori numerici del valore 1. Si fa una di­stin­zio­ne tra l’operatore di pre-in­cre­men­to, l’operatore di pre-de­cre­men­to, l’operatore di post-in­cre­men­to e l’operatore di post-de­cre­men­to.

Ope­ra­zio­ne Operatore Risultato
Pre-in­cre­men­to ++$number L’operatore ++ in­cre­men­ta il valore della variabile $number. Di con­se­guen­za il valore aumenta di 1. Il risultato viene emesso come nuovo valore di $number.
Pre-de­cre­men­to --$number L’operatore -- de­cre­men­ta il valore della variabile $number. Di con­se­guen­za il valore de­cre­men­ta di 1. Il risultato viene emesso come nuovo valore di $number.
Post-in­cre­men­to $number++ Il valore attuale di $number viene prima emesso e poi in­cre­men­ta­to del valore 1.
Post-de­cre­men­to $number-- Il valore attuale di $number viene prima emesso e poi de­cre­men­ta­to del valore 1.

Per di­mo­stra­re le ope­ra­zio­ni arit­me­ti­che con gli operatori di in­cre­men­to o de­cre­men­to, uti­liz­zia­mo l’esempio del pre-in­cre­men­to. Il seguente script in­cre­men­ta di 1 il valore della variabile $number, memorizza il nuovo valore nella variabile $result e quindi ne emette il valore come stringa:

<?php
$number = 0;
$result = ++$number;
echo "Result: " . $result;
php

Au­men­tan­do di 1 il valore 0, si ottiene il risultato 1.

Immagine: Pre-incremento del numero 0
Il pre-in­cre­men­to aumenta il valore della variabile di uno prima che venga re­sti­tui­ta.

Per calcolare il pre-de­cre­men­to della variabile $number, ri­cor­ria­mo agli stessi script, ma scam­bian­do l’operatore di pre-in­cre­men­to (++) con quello di pre-de­cre­men­to (--):

<?php
$number = 0;
$result = --$number;
echo "Result: " . $result;
php

In questo modo si de­cre­men­ta il valore 0 della variabile $number e si ottiene il risultato -1.

L’aumento prima e dopo l’emissione (pre- e post-…) di un valore può essere esem­pli­fi­ca­to dal seguente script:

<?php
$x = 0;
echo '<p>Result: ' . ++$x;
echo '<br>X has the value ' . $x;
echo '<p>Result: ' . $x++;
echo '<br>X has the value ' . $x, '</p>';
php

In entrambi i casi si ottiene lo stesso risultato. Nel caso del pre-in­cre­men­to, il valore x viene in­cre­men­ta­to prima dell’output alla riga 3, mentre nel caso del post-in­cre­men­to dopo l’output alla riga 5.

Immagine: La differenza tra pre- e post-incremento
Con il pre-in­cre­men­to il valore della variabile viene aumentato prima della vi­sua­liz­za­zio­ne; con il post-in­cre­men­to, invece, dopo.

Tipi scalari e union

PHP permette di assegnare alle variabili, ai parametri di funzione e ai valori di ritorno i co­sid­det­ti tipi scalari. Tra questi rientrano, tra gli altri, int, float, string e bool. Grazie all’in­di­ca­zio­ne esplicita del tipo si sta­bi­li­sce quale tipo di valori una funzione si aspetta e re­sti­tui­sce. Questo aumenta la leg­gi­bi­li­tà del codice e aiuta a in­di­vi­dua­re tem­pe­sti­va­men­te errori tipici.

<?php
declare(strict_types=1);

function hi(string $name): string {
return "Hello " . $name;
}
php

In questo esempio, la funzione per­so­na­liz­za­ta hi() si aspetta una stringa come parametro e re­sti­tui­sce anch’essa una stringa. Se viene passato un altro tipo di dato, PHP segnala un errore. In alcune si­tua­zio­ni, però, una funzione deve accettare più di un tipo di dato. A questo scopo PHP mette a di­spo­si­zio­ne i co­sid­det­ti tipi union. Questi per­met­to­no di definire più tipi possibili, separati dal carattere pipe |:

<?php
declare(strict_types=1);

function formatId(int|string $id): string {
return "ID: " . $id;
}
php

La funzione formatId() accetta qui sia numeri interi sia stringhe come parametro. Altri tipi di dato non sono con­sen­ti­ti. I tipi union per­met­to­no quindi firme di funzione fles­si­bi­li, ma comunque con­trol­la­te.

Le variabili su­per­glo­ba­li $_GET e $_POST

Ora conosci le basi di PHP, sai come gestire le variabili, puoi con­ca­te­nar­le e uti­liz­zar­le per eseguire calcoli. È giunto il momento di mostrarti perché le variabili sono un concetto centrale nella pro­gram­ma­zio­ne degli script.

Una funzione im­por­tan­te dei linguaggi di scripting è la capacità di valutare gli input dell’utente e di tra­sfe­ri­re i valori a un altro script. Per il tra­sfe­ri­men­to dei dati, PHP ricorre alle variabili di sistema su­per­glo­ba­li $_GET e $_POST, variabili pre­de­fi­ni­te e di­spo­ni­bi­li in tutti gli ambiti di validità. In qualità di array as­so­cia­ti­vi, $_GET e $_POST me­mo­riz­za­no un insieme di variabili sotto forma di stringhe in una variabile su­per­glo­ba­le.

Possiamo pensare agli array PHP come a un comò con diversi cassetti. Ciascuno di questi cassetti offre la pos­si­bi­li­tà di me­mo­riz­za­re dati. Per sapere anche in futuro che cosa contiene ogni cassetto, li eti­chet­tia­mo con un nome di variabile. A seconda del tipo di array, il nome può essere un indice (index) o una chiave (key). Mentre negli array in­di­ciz­za­ti, a ogni cassetto viene assegnato un indice sotto forma di numero, in un array as­so­cia­ti­vo i cassetti si eti­chet­ta­no con una chiave sotto forma di stringa.

Le variabili su­per­glo­ba­li $_GET e $_POST con­ten­go­no una serie di variabili sotto forma di chiavi che con­sen­to­no di ottenere i valori associati a tali chiavi. Andiamo a esa­mi­nar­le nel dettaglio.

Tra­smis­sio­ne dei dati tramite $_GET

La su­per­glo­ba­le $_GET rap­pre­sen­ta un array di variabili che vengono trasmesse in uno script PHP tramite un URL.

Se ti capita di fre­quen­ta­re blog, negozi online o forum su internet, potresti aver notato degli URL formulati in modo insolito. Di solito la loro struttura segue il seguente schema:

http://nomehost/cartella/nomefile.php?nomevariabile=valorevariabile

Nel caso di un blog, lo schema potrebbe apparire così:

http://www.blog-esempio.it/index.php?id=1

Un URL di questo tipo può essere decifrato in modo molto semplice: su un server con un dominio “blog-esempio.it”, si trova un file chiamato “index.php”, che viene uti­liz­za­to per creare un sito web dinamico. Questo file nor­mal­men­te contiene codice HTML e PHP, nonché ri­fe­ri­men­ti a file di template e fogli di stile esterni: in breve, tutto ciò che è ne­ces­sa­rio per vi­sua­liz­za­re un sito web.

L’aggiunta id=1 dopo il punto in­ter­ro­ga­ti­vo (?) indica che pro­ba­bil­men­te abbiamo a che fare con un sito web dinamico. Si tratta di una stringa di ricerca basata sul pro­to­col­lo HTTP che contiene una variabile (id) e un valore (1) collegati da un segno di uguale (=). I parametri URL di questo tipo vengono uti­liz­za­ti, ad esempio, per creare pagine web dinamiche, caricare contenuti da un database o ri­chia­ma­re un template.

I siti web dinamici con­sen­to­no di separare i contenuti dalla veste grafica. Il file “index.php” comprende quindi tutte le in­for­ma­zio­ni sulla struttura del sito web, ma deve ancora essere riempito con i contenuti. Ti­pi­ca­men­te, questi sono me­mo­riz­za­ti in un database e possono essere ri­chia­ma­ti tramite i parametri della stringa di ricerca HTTP. Nel nostro esempio, l’URL trasmette a “index.php” il parametro id=1. Questo parametro sta­bi­li­sce quali contenuti devono essere letti dal database e caricati in “index.php”. Nel caso di un blog potrebbe trattarsi dell’ID di un articolo, in un forum di una di­scus­sio­ne e in un negozio online di un prodotto.

Se un URL contiene più di un parametro, questi vengono collegati con una e com­mer­cia­le (&).

www.blog-esempio.it/index.php?page=article&id=1

Per il­lu­stra­re l’uso di $_GET con un esempio di codice, possiamo anche fare a meno di un database. Nello script seguente, uti­liz­zia­mo la su­per­glo­ba­le $_GET per leggere i valori delle variabili firstname (nome) e lastname (cognome) da una stringa di ricerca HTTP e scriverli nelle variabili PHP $variable1 e $variable2:

<?php

$variable1 = $_GET['firstname'];
$variable2 = $_GET['lastname'];

echo "Hello " . $variable1 . " " . $variable2 . "!";
php

L’ese­cu­zio­ne dello script avviene tramite il seguente URL:

localhost/hello.php?firstname=John&lastname=Doe

In questo modo tra­smet­tia­mo i parametri firstname=John e lastname=Doe. I valori vengono emessi come prima con l’aiuto del costrutto lin­gui­sti­co echo.

Immagine: Trasmissione dei dati tramite $_GET
Con $_GET puoi leggere i valori delle tue variabili dall’URL.

La tra­smis­sio­ne dei dati tramite $_GET comporta ne­ces­sa­ria­men­te che i dati trasmessi siano visibili nella barra degli indirizzi. In questo modo è possibile capire in qualsiasi momento quali parametri vengono trasmessi. Il vantaggio di ciò è che le variabili possono essere salvate nei col­le­ga­men­ti iper­te­stua­li. Inoltre, l’utente ha la pos­si­bi­li­tà di creare URL com­pren­si­vi di stringa di ricerca sotto forma di se­gna­li­bro nel browser.

Il fatto che il parametro GET venga eseguito nel testo in chiaro nell’URL di­squa­li­fi­ca questo metodo per la tra­smis­sio­ne di dati sensibili, come ad esempio nel caso di moduli online. Inoltre, il volume dei dati che possono essere inviati tramite $_GET è limitato dalla lunghezza massima degli URL.

N.B.

Queste re­stri­zio­ni possono essere aggirate con il metodo HTTP POST. I dati tra­sfe­ri­ti si trovano nella su­per­glo­ba­le $_POST.

Tra­smis­sio­ne dei dati tramite $_POST

I metodi HTTP GET e POST si dif­fe­ren­zia­no per il modo in cui i dati vengono trasmessi: mentre nel metodo GET i dati da tra­smet­te­re vengono inoltrati come parametro dell’URL, nel corpo (body) di una richiesta HTTP i dati vengono tra­sfe­ri­ti tramite $_POST. Ciò consente di tra­smet­te­re anche grandi quantità di dati da uno script a un altro.

Uno dei campi di ap­pli­ca­zio­ne prin­ci­pa­li del metodo HTTP POST è la tra­smis­sio­ne dati dei moduli HTML. Lo di­mo­stria­mo con l’esempio della re­gi­stra­zio­ne a una new­slet­ter.

Per prima cosa, è ne­ces­sa­rio creare un nuovo file PHP con il nome “page1.php” e inserire il seguente blocco di codice:

<form method="post" action="page2.php" >
Please send the newsletter to: <br />
Your first name: <input type="text" name="firstname" /><br />
Your last name: <input type="text" name="lastname" /><br />
Your email address: <input type="text" name="email" /><br />
<input type="submit" value="Submit form" />
</form>
html

Per creare i moduli viene uti­liz­za­to l’elemento HTML <form>. Ciò comprende due attributi nel tag iniziale: method e action. Con l’attributo method si definisce il metodo di tra­smis­sio­ne, in questo caso HTTP POST. Nell’attributo action viene creato l’URL di uno script che riceve tutti i dati da includere nei campi di input suc­ces­si­vi. Il codice usato da esempio rap­pre­sen­ta un modulo HTML con tre elementi di input (input type="text") e un pulsante di invio (input type="submit"). Il file “page2.php” è definito come de­sti­na­ta­rio dei dati.

Per il­lu­stra­re il tra­sfe­ri­men­to dei dati tramite $_POST, uti­liz­zia­mo un semplice script per la va­lu­ta­zio­ne dei dati del modulo che salva i valori tra­sfe­ri­ti come variabili PHP e li re­sti­tui­sce in forma di testo. A tale scopo, occorre creare un file “page2.php” e scrivere il seguente codice:

<?php
$firstname = $_POST["firstname"];
$lastname = $_POST["lastname"];
$email = $_POST["email"];
echo "Hello " . $firstname . " " . $lastname . ", <br />
You have registered with the following email address: " . $email . ".";
php

Salva entrambi i file PHP nella cartella “htdocs” del tuo server di test e apri “page1.php” tramite l’URL seguente dal browser: http://localhost/page1.php. Nel browser dovresti ora vi­sua­liz­za­re l’in­ter­fac­cia in­te­rat­ti­va del tuo modulo HTML.

Immagine: Immissione di dati tramite un modulo HTML
Ora puoi inserire valori nel modulo HTML, che verranno tra­sfe­ri­ti al tuo altro script.

Inserisci le cre­den­zia­li di accesso e premi il pulsante di invio per tra­sfe­ri­re le variabili da uno script all’altro. Dopo aver con­fer­ma­to l’in­se­ri­men­to in “page1.php”, avverrà im­me­dia­ta­men­te il rein­di­riz­za­men­to a “page2.php”. La finestra del browser mostrerà il risultato dell’ese­cu­zio­ne dello script in base ai dati tra­sfe­ri­ti.

Immagine: Output dei dati utente
I dati sono stati ora tra­sfe­ri­ti all’altro script.

Gli input dell’utente raccolti at­tra­ver­so i campi di input di “page1.php” vengono re­cu­pe­ra­ti da “page2.php” at­tra­ver­so il seguente schema:

$_POST["Nome del campo di input"]

Di con­se­guen­za le righe $firstname = $_POST["firstname"] aprono l’input nel campo firstname e lo salvano nella variabile $firstname. La variabile $firstname può nuo­va­men­te essere emessa tramite echo come stringa.

Il costrutto if e gli operatori di confronto in PHP

Finora abbiamo definito le variabili, le abbiamo tra­sfe­ri­te da uno script all’altro e le abbiamo prodotte come stringhe. Nel prossimo passo, imparerai a collegare l’ese­cu­zio­ne di frammenti di codice a de­ter­mi­na­te con­di­zio­ni.

Il costrutto lin­gui­sti­co if dà la pos­si­bi­li­tà di scrivere script in modo che le istru­zio­ni diventino effettive solo quando viene sod­di­sfat­ta una con­di­zio­ne definita dall’utente, come ad esempio l’in­se­ri­men­to di una password corretta.

Le con­di­zio­ni sono definite in PHP secondo la seguente struttura di base:

<?php
if(expression)
{
statement;
}
php

Il codice va letto nel modo seguente: la di­chia­ra­zio­ne statement viene eseguita solo se la con­di­zio­ne contenuta nell’espres­sio­ne (expression) è sod­di­sfat­ta. Una con­di­zio­ne è sempre sod­di­sfat­ta se il costrutto if re­sti­tui­sce il risultato TRUE (vero). In caso contrario, viene con­si­de­ra­ta FALSE (falsa). In questo caso, l’istru­zio­ne viene saltata.

So­li­ta­men­te il costrutto if verifica che il valore di una variabile cor­ri­spon­da a quello che è stato definito nella con­di­zio­ne. Questa struttura di controllo viene nor­mal­men­te rea­liz­za­ta sulla base di operatori di confronto.

Operatori di confronto

Gli operatori di confronto vengono uti­liz­za­ti nella for­mu­la­zio­ne di con­di­zio­ni per mettere in cor­re­la­zio­ne logica due argomenti, che possono essere valutati come veri (TRUE) o falsi (FALSE). Quando gli operatori di confronto vengono uti­liz­za­ti nelle strutture di controllo PHP, questi vengono applicati su due variabili nell’espres­sio­ne di un costrutto if:

if ($a == $b)
{
statement;
}
php

La struttura di controllo può dunque essere letta in questo modo: se la variabile $a è uguale alla variabile $b, verranno eseguite le istru­zio­ni definite nella di­chia­ra­zio­ne.

Gli operatori di confronto di PHP si basano sul lin­guag­gio di pro­gram­ma­zio­ne C. Per quanto possano apparire simili ai classici simboli ma­te­ma­ti­ci nella loro notazione, si dif­fe­ren­zia­no da questi ultimi per molti aspetti, a volte anche piuttosto so­stan­zia­li. Nella tabella seguente è riportata una pa­no­ra­mi­ca.

Operatore di confronto De­scri­zio­ne Con­di­zio­ne
== è uguale La con­di­zio­ne è sod­di­sfat­ta se $a e $b hanno lo stesso valore.
=== è identico La con­di­zio­ne è sod­di­sfat­ta se $a e $b hanno lo stesso valore e ap­par­ten­go­no allo stesso tipo di dati. È possibile il­lu­stra­re questo aspetto con un esempio in cui un integer (1) viene con­fron­ta­to con una stringa (“1”): 1 == "1" diventa TRUE e 1 === "1" diventa FALSE Per le con­di­zio­ni che ri­chie­do­no l’ugua­glian­za di due variabili, è meglio uti­liz­za­re sempre l’operatore re­la­zio­na­le === (è identico).
!= è diverso La con­di­zio­ne è sod­di­sfat­ta quando $a e $b hanno valori dif­fe­ren­ti.
!== non identico La con­di­zio­ne è sod­di­sfat­ta se $a e $b hanno valori non uguali o ap­par­ten­go­no a tipi di dati diversi.
< è minore di La con­di­zio­ne è sod­di­sfat­ta se il valore di $a è minore del valore di $b.
> è maggiore di La con­di­zio­ne è sod­di­sfat­ta se il valore di $a è maggiore del valore di $b.
<= è minore o uguale La con­di­zio­ne è sod­di­sfat­ta se il valore di $a è minore del valore di $b o se $a e $b hanno lo stesso valore.
>= è maggiore o uguale La con­di­zio­ne è sod­di­sfat­ta se il valore di $a è maggiore del valore di $b o se $a e $b hanno lo stesso valore.

Il seguente script ha lo scopo di il­lu­stra­re questa struttura di controllo. Vengono con­fron­ta­ti due integer. L’operatore di confronto è < (è minore di):

<?php
$number1 = 10;
$number2 = 20;

if ($number1 < $number2) {
echo "The condition is met";
}
php

Definiamo le variabili $number1 e $number2 e as­se­gnia­mo loro i valori 10 e 20. Quindi im­po­stia­mo una con­di­zio­ne: se $number1 è minore di $number2, viene emessa la stringa elencata nell’istru­zio­ne echo.

Il risultato dell’ese­cu­zio­ne dello script contiene la risposta: 10 è minore di 20. Il costrutto if re­sti­tui­sce il risultato TRUE. La con­di­zio­ne è sod­di­sfat­ta.

Immagine: Applicazione del costrutto linguistico if
Il codice dopo l’istru­zio­ne if viene eseguito quando la con­di­zio­ne spe­ci­fi­ca­ta è sod­di­sfat­ta.

Se desideri definire istru­zio­ni da eseguire non appena una con­di­zio­ne non è sod­di­sfat­ta, aggiungi il costrutto lin­gui­sti­co else alla struttura di controllo if per creare un’istru­zio­ne con­di­zio­na­le if else in PHP:

<?php
if(Condition a)
{
statement b;
}
else
{
statement c;
}
php

Questo script controlla anche se la con­di­zio­ne a re­sti­tui­sce il risultato TRUE o FALSE. Se la con­di­zio­ne a è sod­di­sfat­ta, viene eseguita l’istru­zio­ne b. Se la con­di­zio­ne a non è sod­di­sfat­ta (FALSE), l’istru­zio­ne b viene saltata e al suo posto viene eseguita l’istru­zio­ne c.

Esten­dia­mo il nostro script con il costrutto else e so­sti­tuia­mo l’operatore di confronto < (è minore di) con == (è uguale):

<?php
$number1 = 10;
$number2 = 20;
if($number1 == $number2)
{
echo "The condition is met";
}
else
{
echo "The condition is not met";
}
php

Questa volta il costrutto if re­sti­tui­sce il risultato FALSE. Il valore della variabile $number1 non è uguale al valore della variabile $number2. La con­di­zio­ne non è sod­di­sfat­ta. Pertanto, non viene eseguita l’istru­zio­ne definita sotto if, bensì quella definita sotto else.

Immagine: Applicazione del costrutto linguistico else
Se la con­di­zio­ne if non è sod­di­sfat­ta, viene eseguito il codice che segue l’istru­zio­ne else.
N.B.

Se l’ese­cu­zio­ne di una parte di codice è collegata all’ugua­glian­za di due valori, in PHP viene uti­liz­za­to un doppio segno di uguale (==). Il segno di uguale semplice (=) va uti­liz­za­to esclu­si­va­men­te nell’as­se­gna­zio­ne di valori a variabili.

La negazione delle con­di­zio­ni avviene mediante un punto escla­ma­ti­vo (!) anteposto.

<?php
$number1 = 10;
$number2 = 20;

if ($number1 == $number2)
{
echo "The numbers are equal.";
}
if (!($number1 == $number2))
{
echo "The numbers are not equal.";
}
php

L’esempio mostra la con­di­zio­ne $number1 == $number2 e la loro negazione. !($number1 == $number2) cor­ri­spon­de a ($number1 != $number2).

Un’ap­pli­ca­zio­ne pratica di if ed else è, per esempio, la richiesta di password basata su un modulo HTML. Simuliamo ancora una volta questo caso uti­liz­zan­do i nostri file PHP “page1.php” e “page2.php”.

Apri “page1.php” e incolla il seguente codice nel modulo:

<form action="page2.php" method="post">
Please enter your password: <input type="password" name="password" />
<input type="submit" value="Submit" />
</form>
html

La struttura cor­ri­spon­de al modulo già creato. Questa volta, però, è suf­fi­cien­te un solo campo di input: la richiesta della password. Come in pre­ce­den­za, l’input dell’utente viene trasmesso allo script “page2.php”.

Adattiamo il codice seguente in modo che l’in­se­ri­men­to della password sia abbinato a una password me­mo­riz­za­ta:

<?php
$password = $_POST["password"];
if($password=="qwertz123")
{
echo "The password was correct";
}
else
{
echo "The password was incorrect";
}
php

Il codice si legge come segue: per prima cosa, nella riga 2 as­se­gnia­mo un valore alla variabile $password, che re­cu­pe­ria­mo tramite il metodo HTTP POST. Quindi definiamo la seguente struttura di controllo: la struttura if nella riga 3 serve a ve­ri­fi­ca­re se il valore della variabile $password cor­ri­spon­de alla stringa qwertz123. In caso af­fer­ma­ti­vo, viene emessa la stringa “The password was correct” (La password è corretta). Se if re­sti­tui­sce il risultato FALSE, nella riga 7 viene uti­liz­za­to else e viene emessa la stringa “The password was incorrect” (La password è errata).

Ora apriamo lo script “page1.php” tramite l’URL http://localhost/page1.php.

Immagine: Interfaccia utente del modulo HTML con richiesta di inserimento della password
Nel modulo web puoi ora inserire una password.

Il browser presenta la vi­sua­liz­za­zio­ne web del modulo HTML per la richiesta della password. Ac­cet­tia­mo la richiesta, inseriamo la password “qwertz123” definita nello script “page2.php” e facciamo clic sul pulsante di invio.

Immagine: La password inserita è corretta
Se hai inserito la password corretta, la con­di­zio­ne if dello script viene sod­di­sfat­ta e viene vi­sua­liz­za­to un messaggio di successo.

Il browser web rein­di­riz­za au­to­ma­ti­ca­men­te a “page2.php”. In back­ground, la struttura di controllo if confronta il nostro input con la password me­mo­riz­za­ta e giunge al seguente verdetto: “qwertz123 == qwertz123 è TRUE”, emettendo così la stringa “The password was correct”. Verifica per­so­nal­men­te cosa succede digitando una password diversa nel campo di im­mis­sio­ne.

Operatori logici

Le con­di­zio­ni definite uti­liz­zan­do gli operatori di confronto nell’espres­sio­ne del costrutto if possono essere collegate ad altre con­di­zio­ni nella stessa espres­sio­ne, se ne­ces­sa­rio. PHP si basa sugli operatori logici AND e OR.

Alias simbolico Operatore De­scri­zio­ne
&& AND Entrambe le con­di­zio­ni associate all’operatore devono essere TRUE.
|| OR Solo una delle due con­di­zio­ni associate all’operatore deve essere TRUE.

Per collegare le con­di­zio­ni, PHP fornisce operatori logici con elementi di unione vin­co­lan­ti e poco vin­co­lan­ti. Uti­liz­zan­do solo una delle due notazioni, non si noterà alcuna dif­fe­ren­za nella pratica. Com­bi­nan­do entrambe le notazioni, si noterà che && e || vincolano più stret­ta­men­te di AND e OR. Questo è pa­ra­go­na­bi­le all’ordine di pre­ce­den­za degli operatori ma­te­ma­ti­ci (ad esempio, punto prima della linea: * è più vin­co­lan­te rispetto a +).

Un esempio pratico è fornito dalla richiesta di password. Di norma, i dati di login com­pren­do­no una password segreta e un nome utente. Solo se entrambe le voci cor­ri­spon­do­no ai dati me­mo­riz­za­ti nel sistema, il login va a buon fine.

Riapriamo il modulo di richiesta della password in “page1.php” e ag­giun­gia­mo un campo di input per il nome utente:

<form action="page2.php" method="post">
Username: <input type="text" name="username" /><br />
Password: <input type="password" name="password" /><br />
<input type="submit" value="Submit" />
</form>
html

Nel prossimo passaggio, dobbiamo adattare anche la struttura di controllo del costrutto if. Uti­liz­zia­mo l’operatore logico AND per collegare la con­di­zio­ne per la richiesta della password con la con­di­zio­ne per la richiesta del nome utente.

<?php
$username = $_POST["username"];
$password = $_POST["password"];
if($username=="John Doe" AND $password=="qwertz123")
{
echo "Welcome to the members area " . $username . "!";
}
else
{
echo "Access denied";
}
php

Il nostro script “page2.php” ora riceve i valori di username e password e li memorizza nelle variabili $username e $password. L’espres­sio­ne del costrutto if contiene ora due con­di­zio­ni collegate dall’operatore logico AND. Solo se entrambe le con­di­zio­ni sono sod­di­sfat­te ($username=="John Doe" e $password=="qwertz123"), if re­sti­tui­sce il risultato TRUE.

Poiché il nome utente viene ottenuto tramite il campo di input username, possiamo uti­liz­zar­lo di­ret­ta­men­te per l’output di testo tramite echo: “Welcome to the members area” (Ti diamo il benvenuto nell’area riservata) è seguito dal valore della variabile $username. Se una delle due con­di­zio­ni non è sod­di­sfat­ta, viene vi­sua­liz­za­to il testo: “Access denied” (Accesso negato).

Immagine: Richiesta della password con due condizioni
Solo se entrambe le con­di­zio­ni collegate con AND vengono valutate come TRUE, l’accesso va a buon fine.

Gli operatori logici possono essere combinati in qualsiasi modo. Si applica quanto segue: AND ha una posizione più alta rispetto a OR. Come per le equazioni ma­te­ma­ti­che, anche in PHP è possibile uti­liz­za­re le parentesi per in­fluen­za­re l’ordine.

Con­di­zio­ni con match

Finora abbiamo gestito le decisioni in PHP con le istru­zio­ni if e else. Tuttavia, quando viene ve­ri­fi­ca­to un singolo valore e in base a questo devono risultare esiti diversi, il codice con if può diventare ra­pi­da­men­te poco chiaro. Proprio per questi casi esiste l’istru­zio­ne match.

<?php
$status = 404;
echo match ($status) {
200 => "OK",
404 => "Not found",
default => "Unknown status",
};
php

In questo esempio viene ve­ri­fi­ca­to il valore della variabile $status. Se cor­ri­spon­de al valore 200, match re­sti­tui­sce il testo “OK”. Se il valore è 404, viene impostato “Not found” (non trovato). Se nessuno dei valori indicati cor­ri­spon­de, si applica il caso default e viene usato “Unknown status” (stato sco­no­sciu­to).

Immagine: Messaggio “Not found”
Poiché la variabile $status è impostata sul valore 404, si applica il secondo caso della con­di­zio­ne match e otteniamo il messaggio “Not found” (non trovato).

La dif­fe­ren­za più im­por­tan­te rispetto a if-else è che match re­sti­tui­sce di­ret­ta­men­te un valore che può essere assegnato a una variabile. In questo modo si evita di scrivere più volte le as­se­gna­zio­ni all’interno delle singole con­di­zio­ni e il codice rimane più corto, ordinato e di più facile com­pren­sio­ne.

Cicli o loop (while, for)

A volte è ne­ces­sa­rio che uno script esegua più volte una de­ter­mi­na­ta sezione di codice prima che venga eseguito il resto del codice del programma. Il lin­guag­gio di pro­gram­ma­zio­ne PHP utilizza il concetto di ciclo (loop), chiamato anche ciclo PHP. Esistono tre tipi di cicli:

  • while
  • do-while
  • for

Ciclo while

Il ciclo while è il tipo più semplice di ciclo di­spo­ni­bi­le in PHP. La struttura di base cor­ri­spon­de al seguente schema:

while (condition)
{
loop step and other statements
}
php

Il ciclo while indica a PHP di eseguire le istru­zio­ni su­bor­di­na­te fintanto che la con­di­zio­ne while è sod­di­sfat­ta. Per fare ciò, l’in­ter­pre­te PHP controlla la con­di­zio­ne all’inizio di ogni passaggio del ciclo. L’ese­cu­zio­ne del codice su­bor­di­na­to si in­ter­rom­pe solo quando la con­di­zio­ne while non è più sod­di­sfat­ta.

Questo principio può essere il­lu­stra­to con un semplice script numerico:

<?php
$number = 1;
while ($number <= 10) {
echo $number++ . "<br />";
}
php

Abbiamo pre­ce­den­te­men­te in­tro­dot­to il principio dell’in­cre­men­to nella sezione “Calcolo con le variabili”. Nello script che segue ci ri­fac­cia­mo a questo principio, uti­liz­zan­do però un operatore di post-in­cre­men­to per aumentare il valore della variabile intera $number di 1 per ogni passaggio del ciclo solo dopo l’output del testo tramite echo. Come con­di­zio­ne per il ciclo while definiamo: $number minore di/uguale a 10. L’istru­zio­ne echo viene quindi ripetuta fino a quando $number non ha assunto un valore maggiore di 10.

Immagine: Lo script conta fino a 10 e poi si interrompe
Non appena viene raggiunto il valore 10, il ciclo si in­ter­rom­pe.

Il risultato dell’ese­cu­zio­ne dello script è una stringa che riporta il valore della variabile $number per ogni passaggio del ciclo prima che venga in­cre­men­ta­to. Pertanto, lo script conta da 1 a 10 e termina l’ese­cu­zio­ne del codice quando la con­di­zio­ne while non è più sod­di­sfat­ta.

Ciclo do-while

La struttura del ciclo do-while as­so­mi­glia a quella del ciclo while. L’unica dif­fe­ren­za è che la con­di­zio­ne non viene con­trol­la­ta all’inizio di ogni passaggio del ciclo, bensì solo alla fine. Nel seguente esempio, vediamo come appare lo schema di base di un ciclo do-while:

do {
loop step and other statements
}
while (condition);
php

Se pro­gram­ma­to come un ciclo do-while, lo script pre­ce­den­te si pre­sen­te­reb­be così:

<?php
$number = 1;
do {
echo $number++ . "<br />";
}
while ($number <= 10);
php

In questo caso, il risultato rimane lo stesso. La pe­cu­lia­ri­tà del ciclo do-while è che viene eseguito almeno una volta, anche se la con­di­zio­ne non viene sod­di­sfat­ta in nessun passaggio del ciclo.

Ciclo for

In pratica, il ciclo for in uno script PHP ha la stessa fun­zio­na­li­tà del ciclo while. Di­ver­sa­men­te da quest’ultimo, però, il valore di inizio, la con­di­zio­ne e l’istru­zio­ne si trovano all’interno di un’unica riga e non di­stri­bui­ti su tre o più righe. La struttura di base del ciclo for è la seguente:

for (initial value; condition; loop step)
statements
php

L’esempio già noto potrebbe quindi essere scritto come un ciclo for in forma compatta:

<?php
for($number = 1; $number <= 10; $number++) {
echo $number . "<br /> ";
}
php

Prima di tutto, viene definito il valore “1” per la variabile $number. Suc­ces­si­va­men­te, PHP verifica se la con­di­zio­ne $number <= 10 è sod­di­sfat­ta. Se sì, il ciclo continua e vengono eseguite le istru­zio­ni suc­ces­si­ve al ciclo (in questo caso l’istru­zio­ne echo). Solo a questo punto viene eseguito il passaggio del ciclo; in questo caso, non importa se si sceglie il pre-in­cre­men­to o il post-in­cre­men­to, perché il risultato di questa istru­zio­ne non viene riu­ti­liz­za­to. Una volta com­ple­ta­to il passaggio del ciclo, inizia il passaggio suc­ces­si­vo.

Il valore di inizio, la con­di­zio­ne e il passaggio del ciclo sono elementi opzionali di un ciclo for. In linea teorica esistono anche cicli vuoti, ma sarebbero ri­don­dan­ti.

Ge­ne­ral­men­te, puoi scegliere se scrivere i tuoi script PHP con un ciclo for o while. C’è però un argomento a favore dei cicli for: as­si­cu­ra­no una migliore visione d’insieme dei dati generali del ciclo. Ciò previene il pericolo di scrivere ac­ci­den­tal­men­te un ciclo infinito che viene eseguito finché la memoria dell’in­ter­pre­te non è piena. Nell’esempio pre­ce­den­te, questo accade quando ci si dimentica di aumentare il valore della variabile $number.

Se però il ciclo deve essere eseguito almeno una volta, in­di­pen­den­te­men­te dalla con­di­zio­ne, la scelta giusta è il ciclo do-while.

break e continue

L’andamento di un ciclo while, do-while o for può essere in­fluen­za­to dalle istru­zio­ni break e continue. Si usa break per in­ter­rom­pe­re il corso di un ciclo in qualsiasi punto e continue per saltare un passaggio del ciclo. Entrambe le istru­zio­ni sono legate a una con­di­zio­ne uti­liz­zan­do if. L’esempio seguente mostra il nostro script numerico con break:

<?php
for ($number = 1; $number <= 10; $number++) {
if ($number == 5) {
echo "At 5, we break out of the loop!";
break;
}
echo $number . "<br /> ";
}
php

Nel ciclo for abbiamo definito che il valore della variabile $number, a partire da un valore iniziale di 1, deve essere in­cre­men­ta­to del valore 1 a ogni ciclo fino a quando la variabile non avrà raggiunto il valore 10. In­ter­rom­pia­mo questo ciclo pre­ma­tu­ra­men­te con l’istru­zio­ne break non appena $number ha raggiunto il valore 5. Il costrutto lin­gui­sti­co echo produrrà quindi soltanto i numeri da 1 a 4.

Immagine: Ciclo for con break
Con break puoi uscire da un ciclo non appena viene sod­di­sfat­ta una de­ter­mi­na­ta con­di­zio­ne if.

Se vogliamo saltare solo l’output del quinto ciclo senza in­ter­rom­pe­re l’intero ciclo, so­sti­tuia­mo l’istru­zio­ne break con continue:

<?php
for ($number=1; $number <= 10; $number++) {
if ($number == 5) {
echo "Number 5 is skipped!<br />";
continue;
}
echo $number . "<br /> ";
}
php

Al posto della cifra 5, PHP re­sti­tui­sce la stringa di testo definita in if “Number 5 is skipped!” (saltiamo il numero 5!).

Immagine: Ciclo for con istruzione continue
Con continue puoi saltare un’ite­ra­zio­ne del ciclo quando si verifica una de­ter­mi­na­ta con­di­zio­ne.

Ope­ra­zio­ni con i file

I contenuti web dinamici prevedono la se­pa­ra­zio­ne tra contenuto e pre­sen­ta­zio­ne. I linguaggi di scripting, come PHP, for­ni­sco­no varie fun­zio­na­li­tà che con­sen­to­no di caricare contenuti da fonti di dati esterne in file di modelli centrali. So­stan­zial­men­te, queste fonti di dati sono database gestiti con sistemi di gestione come MySQL. Inoltre, esiste la pos­si­bi­li­tà di integrare dati da file. Vediamo di seguito come leggere i file come stringhe in uno script PHP e come salvare gli output di testo del tuo script in un file.

Leggere i file

Per leggere il contenuto di un file, PHP fornisce diverse funzioni, tra cui file() e file_get_contents() che sono par­ti­co­lar­men­te adatte ai nostri scopi. Mentre la funzione file_get_contents() legge l’intero contenuto di un file in una stringa, la funzione file() memorizza il contenuto come un array. Ogni elemento dell’array cor­ri­spon­de a una riga del file. Uti­liz­zan­do file() è quindi più facile produrre ogni riga sin­go­lar­men­te.

Di­mo­stria­mo le ope­ra­zio­ni con i file PHP sul file di testo “example.txt”, collocato nella cartella “htdocs” del nostro server di prova. Il contenuto del file è co­sti­tui­to da quattro righe di testo di esempio:

Immagine: File di testo con quattro righe di testo di esempio
Nel nostro file di testo ci sono quattro righe di testo se­gna­po­sto di esempio.

Per prima cosa leggiamo l’intero file come una stringa. A tale scopo, dobbiamo assegnare il nome del file in questione come parametro alla funzione file_get_contents(). Ciò avviene secondo il seguente schema:

file_get_contents('example.txt')

Ora è possibile lavorare con la stringa letta. Possiamo, ad esempio, as­se­gnar­la a una variabile e vi­sua­liz­zar­la come testo sul browser web:

<?php
$example = file_get_contents('example.txt');
echo $example;
php

Nella vista del browser, os­ser­via­mo che la stringa di testo viene generata senza paragrafi. Le in­ter­ru­zio­ni di riga del file originale non sono visibili. Ciò è dovuto al fatto che il browser web in­ter­pre­ta l’output di testo dello script come codice HTML. Le in­ter­ru­zio­ni di riga definite negli editor di testo vanno quindi perse.

Immagine: Lo script legge il file example.txt.
Con la funzione file_get_contents() puoi leggere il contenuto di un file e poi ela­bo­rar­lo in PHP.

Se desideri attenerti alla struttura originale, hai diverse opzioni. Ad esempio, puoi ag­giun­ge­re ma­nual­men­te la codifica HTML per l’in­ter­ru­zio­ne di riga (<br>) nel file sorgente usando il tasto cerca e so­sti­tui­sci, inserire un <pre> intorno al contenuto del file, assegnare la proprietà CSS white-space: pre-wrap all’area o usare la funzione nl2br() per segnalare a PHP che le in­ter­ru­zio­ni di riga devono essere con­ver­ti­te au­to­ma­ti­ca­men­te in in­ter­ru­zio­ni di riga HTML. La funzione va uti­liz­za­ta secondo il seguente schema:

<?php
$example = file_get_contents('example.txt');
echo nl2br($example);
php

Se il costrutto lin­gui­sti­co echo viene usato in com­bi­na­zio­ne con nl2br(), PHP inserirà un’in­ter­ru­zio­ne di riga HTML prima di ogni nuova riga.

Immagine: Applicazione della funzione nl2br()
Con la funzione PHP nl2br() puoi generare in­ter­ru­zio­ni di riga.

Se desideri emettere le righe di un file sin­go­lar­men­te, puoi avvalerti della funzione file(). Questa funzione legge un file, numera tutte le righe iniziando da 0 e ne memorizza il contenuto come elementi di un array. Applicato al nostro esempio, il risultato è la seguente as­se­gna­zio­ne:

[0] = Lorem ipsum dolor sit amet, consectetuer adipiscing elit

[1] = Aenean commodo ligula eget dolor. Aenean massa.

[2] = Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus.

[3] = Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem.

Per vi­sua­liz­za­re il contenuto del file uti­liz­zan­do echo basta spe­ci­fi­ca­re il numero di riga de­si­de­ra­to. Ad esempio, lo script seguente fornisce solo la prima riga del file example.txt come output sul browser:

<?php
$example = file("example.txt");
echo $example [0];
php
Immagine: Applicazione della funzione file()
La funzione file() è adatta alla lettura di singole righe da un file.

Scrivere file

PHP non consente solo di leggere i file, ma offre anche la pos­si­bi­li­tà di crearli e de­scri­ver­li per mezzo di contenuti.

A tale scopo uti­liz­zia­mo la funzione PHP file_put_contents(). Questa funzione necessita di due parametri: il nome del file da creare o ag­gior­na­re e i dati sotto forma di stringa o array. Lo script seguente crea il file test.txt e scrive la stringa This is a test! (Questo è un test!) nella prima riga. L’aggiunta \r\n porta a un’in­ter­ru­zio­ne di riga nel file di de­sti­na­zio­ne.

<?php
file_put_contents("test.txt", "This is a test! \r\n");
echo "test.txt has been created!";
php

Dal momento che file_put_contents non fornisce alcun output per il browser, ag­giun­gia­mo un’istru­zio­ne echo che ci comunica quale azione viene eseguita.

Immagine: Operazioni con i file: scrivere file
Con la funzione file_put_contents() puoi scrivere file.

Se nella cartella di de­sti­na­zio­ne è già presente un file con lo stesso nome, esso verrà so­vra­scrit­to. Per evitare che ciò accada, imposta il parametro FILE_APPEND:

<?php
file_put_contents("test.txt","The test was successful! \r\n", FILE_APPEND);
echo "test.txt has been updated!";
php

Uti­liz­zan­do file_put_contents() con il parametro FILE_APPEND, i nuovi contenuti vengono aggiunti a quelli esistenti.

Immagine: Operazioni con i file: aggiornare i file
Se aggiungi il parametro FILE_APPEND, i contenuti che passi a file_put_contents vengono aggiunti in coda al tuo file.

Il contenuto scritto da PHP nel file di de­sti­na­zio­ne non deve ne­ces­sa­ria­men­te essere definito nello script. Come al­ter­na­ti­va, puoi scegliere di tra­sfe­ri­re il contenuto da un file a un altro. Lo script seguente legge il contenuto di example.txt e lo inserisce nel file test.txt:

<?php
$example = file_get_contents("example.txt");
file_put_contents("test.txt", $example, FILE_APPEND);
echo "test.txt has been updated!";
php
MyWebsite Now Plus
Crea il tuo sito web aziendale
  • Im­po­sta­zio­ni SEO integrate
  • Strumento per pre­no­ta­zio­ni online
  • Dominio e cer­ti­fi­ca­to SSL inclusi

Pro­gram­ma­zio­ne orientata agli oggetti

La pro­gram­ma­zio­ne orientata agli oggetti (OOP) è un metodo per sud­di­vi­de­re i programmi in piccoli blocchi gestibili, i co­sid­det­ti oggetti. Ogni oggetto ap­par­tie­ne a una classe che descrive quali proprietà e metodi possiede. Le proprietà sono variabili che me­mo­riz­za­no le ca­rat­te­ri­sti­che dell’oggetto, mentre i metodi sono funzioni che l’oggetto può eseguire. L’OOP aiuta a strut­tu­ra­re meglio il codice, a renderlo riu­ti­liz­za­bi­le e più facile da ma­nu­te­ne­re, so­prat­tut­to nei progetti di grandi di­men­sio­ni.

Classi

Una classe è il modello per un oggetto. Si può im­ma­gi­na­re una classe come un progetto, per esempio per un’auto, mentre un oggetto è l’auto concreta che è stata creata seguendo quel progetto. Definisce quali dati contiene un oggetto e quali funzioni può eseguire. Nel seguente esempio vediamo la classe Car:

class Car {
public string $make;
public string $model;
public function move () {
echo "The car is moving!";
}
}
$myCar = new Car();
$myCar->make = "VW";
$myCar->model = "Golf";
$myCar->move();
php

In questo esempio viene definita la classe Car, che ha due proprietà, $make e $model, oltre a un metodo move(). Poi viene creato un oggetto di questa classe as­se­gnan­do la classe “Car” a $myCar. Con -> accediamo alle proprietà dell’oggetto e im­po­stia­mo $make su VW e $model su Golf. Suc­ces­si­va­men­te ri­chia­mia­mo il metodo move(), che re­sti­tui­sce il testo “The car is moving!” (l’auto si sta muovendo). La keyword $this si riferisce all’oggetto corrente all’interno del metodo.

Immagine: Oggetto della classe Car
Dopo che un oggetto della classe Car è stato creato, chiamando la funzione `move()` viene prodotto il cor­ri­spon­den­te output.

Pro­mo­zio­ne della proprietà del co­strut­to­re

A partire da PHP 8.0 è possibile definire e ini­zia­liz­za­re le proprietà di­ret­ta­men­te nel co­strut­to­re, cioè nel metodo che viene ri­chia­ma­to au­to­ma­ti­ca­men­te quando si crea un oggetto di una classe. In questo modo non è più ne­ces­sa­rio di­chia­rar­le prima se­pa­ra­ta­men­te nella classe, rendendo il codice più breve e leggibile.

class Product {
public function __construct(
public string $name,
public float $price
) {} 
} 
$product = new Product("Cup", 12.99);
echo $product->name;
echo $product->price;
php

In questo esempio, le proprietà name e price sono di­chia­ra­te di­ret­ta­men­te nel co­strut­to­re. Quando l’oggetto Product viene creato, i valori “Cup” e “12.99” vengono passati come argomenti. Le espres­sio­ni $product->name e $product->price vengono poi usate per accedere ai valori impostati au­to­ma­ti­ca­men­te. La pro­mo­zio­ne della proprietà del co­strut­to­re riduce la quantità di codice e migliora la leg­gi­bi­li­tà.

In­ter­fac­ce

Un’in­ter­fac­cia definisce quali metodi deve avere una classe senza spe­ci­fi­car­ne l’im­ple­men­ta­zio­ne concreta. Le classi che im­ple­men­ta­no l’in­ter­fac­cia devono definire questi metodi, così che classi diverse possano essere gestite in modo coerente.

<?php
interface Movable {
    public function move();
}

class Car implements Movable {
    public function move() {
        echo "The car is moving!";
    }
} 
 
$myCar = new Car();
$myCar->move();
php

In questo esempio, l’in­ter­fac­cia Movable specifica che ogni classe che la im­ple­men­ta deve fornire un metodo move(). La classe Car im­ple­men­ta questa in­ter­fac­cia e definisce il metodo di con­se­guen­za. Viene quindi creato un oggetto della classe e il metodo viene chiamato, re­sti­tuen­do il testo “The car is moving!”.

Immagine: Oggetto della classe Car secondo l’interfaccia Movable
Un’in­ter­fac­cia definisce che la nostra classe deve includere un metodo chiamato move().

Tipi di in­ter­se­zio­ne

I tipi di in­ter­se­zio­ne sono di­spo­ni­bi­li da PHP 8.1. Fanno in modo che un oggetto debba sod­di­sfa­re più in­ter­fac­ce con­tem­po­ra­nea­men­te. Questo è par­ti­co­lar­men­te utile quando una funzione deve garantire che un oggetto possieda de­ter­mi­na­te capacità.

interface Loggable {}
function save(JsonSerializable&Loggable $object) {
echo "The object can save JSON data and log information.";
}
php

In questo esempio, gli oggetti passati alla funzione save() devono im­ple­men­ta­re entrambe le in­ter­fac­ce JsonSerializable e Loggable. La com­bi­na­zio­ne delle due in­ter­fac­ce è rap­pre­sen­ta­ta da &. Questo ga­ran­ti­sce che la funzione lavori solo con oggetti che pos­sie­do­no entrambe le ca­rat­te­ri­sti­che.

Proprietà di sola lettura

Le proprietà di sola lettura sono di­spo­ni­bi­li da PHP 8.1. Possono essere impostate una sola volta quando un oggetto viene creato e non possono essere mo­di­fi­ca­te in seguito. Ciò risulta par­ti­co­lar­men­te utile per pro­teg­ge­re i dati sensibili da modifiche in­vo­lon­ta­rie.

class User {
public function __construct(
public readonly string $name
) {} 
} 
$user = new User("Max");
echo $user->name;
php

In questo esempio, la proprietà name è definita di­ret­ta­men­te nel co­strut­to­re e di­chia­ra­ta come readonly. Di con­se­guen­za, il valore “Max” non può essere mo­di­fi­ca­to dopo che l’oggetto è stato creato. Qualsiasi tentativo di cambiarlo in seguito genererà un errore. Le proprietà readonly sono utili per valori che devono rimanere costanti, come gli ID utente o le im­po­sta­zio­ni di con­fi­gu­ra­zio­ne.

Hook delle proprietà

Gli hook delle proprietà sono di­spo­ni­bi­li dalla versione 8.4 di PHP e ti per­met­to­no di eseguire una certa logica di­ret­ta­men­te quando imposti o leggi una proprietà. Questo è utile quando i valori devono essere elaborati au­to­ma­ti­ca­men­te.

class User {
public string $email {
set => strtolower($value);
get => strtoupper($this->email);
}
}
$user = new User();
$user->email = "Test@Example.com";
echo $user->email;
php

In questo esempio, quando un valore viene assegnato alla proprietà email, viene au­to­ma­ti­ca­men­te con­ver­ti­to in minuscolo, mentre in lettura viene re­sti­tui­to tutto au­to­ma­ti­ca­men­te in maiuscolo. Questo ti permette di elaborare i dati in modo coerente senza dover scrivere metodi ag­giun­ti­vi.

Vi­si­bi­li­tà asim­me­tri­ca

Con la vi­si­bi­li­tà asim­me­tri­ca, in­tro­dot­ta in PHP 8.4, è possibile definire che una proprietà possa essere letta pub­bli­ca­men­te ma mo­di­fi­ca­ta solo all’interno della classe stessa. Si pro­teg­go­no così i dati im­por­tan­ti da modifiche non con­trol­la­te.

class Account {
    public private(set) float $balance = 0.0;

    public function deposit(float $amount) {
        $this->balance += $amount;
    }
}

$account = new Account();
$account->deposit(50);
echo $account->balance;
php

In questo esempio, il saldo del conto può essere letto pub­bli­ca­men­te ma può essere mo­di­fi­ca­to solo all’interno della classe. Il metodo deposit() consente di aumentare il saldo in modo con­trol­la­to. Qualsiasi tentativo di mo­di­fi­ca­re di­ret­ta­men­te $balance genera un errore. Questo approccio protegge i dati im­por­tan­ti pur con­sen­ten­do l’accesso tramite le ope­ra­zio­ni con­sen­ti­te.

Scrivere codice PHP pulito

Con l’aumentare delle di­men­sio­ni di un progetto cresce anche l’im­por­tan­za di un codice ben strut­tu­ra­to e scritto in modo pulito. Un codice PHP pulito è più facile da leggere, più semplice da mantenere e meno soggetto a errori. Per questo motivo le ap­pli­ca­zio­ni PHP seguono con­ven­zio­ni spe­ci­fi­che e uti­liz­za­no strumenti che fa­vo­ri­sco­no ordine, chiarezza e sicurezza.

Composer e PSR-4 (ca­ri­ca­men­to au­to­ma­ti­co delle classi)

Composer è uno strumento centrale nello sviluppo PHP. Serve a gestire le librerie esterne e a caricare au­to­ma­ti­ca­men­te le classi PHP. Senza Composer dovresti includere le classi ma­nual­men­te con require o include, cosa che nei progetti più grandi diventa ra­pi­da­men­te poco chiara. Composer utilizza di norma lo standard di au­to­ca­ri­ca­men­to PSR-4. Questo standard definisce come le classi vengono trovate in base al loro nome e alla loro posizione di sal­va­tag­gio. Il nome di una classe cor­ri­spon­de alla struttura di cartelle in cui è me­mo­riz­za­ta.

Un semplice esempio illustra questo principio. Se una classe User ap­par­tie­ne allo spazio dei nomi App\Model, il file cor­ri­spon­den­te si trova nella cartella src/Model:

<?php
namespace App\Model;
class User {
public function getName() {
return "Max Mustermann";
}
}
php

Grazie a PSR-4, questa classe può essere uti­liz­za­ta in qualsiasi punto del progetto senza includere ma­nual­men­te il file. PHP la carica au­to­ma­ti­ca­men­te non appena è ne­ces­sa­ria. Questo rende il codice più or­ga­niz­za­to e riduce le possibili fonti di errore.

Uso dei namespace per una struttura del codice più chiara

Gli spazi dei nomi (namespace) aiutano a rag­grup­pa­re lo­gi­ca­men­te le classi ed evitare conflitti di de­no­mi­na­zio­ne. Nei piccoli script non è un problema chiamare sem­pli­ce­men­te le classi User o Database. Nelle ap­pli­ca­zio­ni più grandi, però, più classi possono con­di­vi­de­re lo stesso nome pur avendo scopi diversi. I namespace ti per­met­to­no di di­stin­gue­re chia­ra­men­te queste classi. Per esempio, può esserci una classe User per il database e un’altra classe User per la vi­sua­liz­za­zio­ne nel front end senza creare conflitti.

L’esempio seguente mostra come viene uti­liz­za­to uno spazio dei nomi:

<?php
namespace App\Service;
class Mailer {
public function send() {
echo "Email has been sent.";
}
}
php

Quando usi la classe, viene uti­liz­za­to il nome completo com­pren­si­vo dello spazio dei nomi oppure viene importato tramite use. In questo modo il codice rimane non ambiguo e ben strut­tu­ra­to.

Struttura del progetto: file .env e .gitignore

Una struttura di progetto chiara è un elemento im­por­tan­te di un codice PHP pulito. I progetti PHP separano il vero e proprio codice del programma dai file pub­bli­ca­men­te ac­ces­si­bi­li e dai dati di con­fi­gu­ra­zio­ne. Spesso il codice PHP si trova in una cartella dedicata, mentre il server web può accedere solo a una directory pubblica.

I valori di con­fi­gu­ra­zio­ne come le cre­den­zia­li di accesso al database o le chiavi API di solito non vengono salvati di­ret­ta­men­te nel codice. Al loro posto si uti­liz­za­no i co­sid­det­ti file .env, in cui questi valori vengono me­mo­riz­za­ti in modo cen­tra­liz­za­to. Questo aumenta la sicurezza e facilita il passaggio tra ambiente di sviluppo e di pro­du­zio­ne.

Un esempio semplice di file .env potrebbe essere il seguente:

DB_HOST=localhost
DB_USER=root
DB_PASSWORD=secret
text

Questo file viene con­sa­pe­vol­men­te non salvato nel sistema di controllo della versione. A questo provvede il file .gitignore, che sta­bi­li­sce quali file o cartelle devono essere ignorati da Git. Nel file .gitignore il file .env viene escluso espli­ci­ta­men­te, in modo che i dati sensibili non vengano pub­bli­ca­ti per errore.

Gestione degli errori e file di log

La gestione degli errori dif­fe­ri­sce tra l’ambiente di sviluppo e quello di pro­du­zio­ne. Durante lo sviluppo è utile vi­sua­liz­za­re di­ret­ta­men­te i messaggi di errore PHP, in modo da ri­co­no­sce­re e risolvere ra­pi­da­men­te i problemi.

Nelle ap­pli­ca­zio­ni di pro­du­zio­ne, invece, i messaggi di errore non do­vreb­be­ro essere visibili, perché po­treb­be­ro rivelare in­for­ma­zio­ni interne. Al loro posto, gli errori vengono scritti in file di log, ac­ces­si­bi­li solo alle svi­lup­pa­tri­ci e agli svi­lup­pa­to­ri.

In un ambiente di sviluppo, l’output degli errori può ad esempio essere attivato in questo modo:

<?php
ini_set('display_errors', 1);
error_reporting(E_ALL);
php

In un ambiente di pro­du­zio­ne viene di­sat­ti­va­ta la vi­sua­liz­za­zio­ne degli errori e attivati i log. PHP scrive quindi gli errori che si ve­ri­fi­ca­no in un file di log, senza mostrarli alle persone che visitano il sito web. In questo modo l’ap­pli­ca­zio­ne rimane stabile e sicura, pur man­te­nen­do una do­cu­men­ta­zio­ne trac­cia­bi­le degli errori.

Nozioni di base di database con PHP: un semplice esempio PDO

Per salvare o leggere dati con PHP, è ne­ces­sa­rio un database. In questo esempio uti­liz­zia­mo MySQL, che è incluso per im­po­sta­zio­ne pre­de­fi­ni­ta in XAMPP. PHP può co­mu­ni­ca­re in modo sicuro con il database tramite PDO, ovvero PHP Data Objects. PDO ga­ran­ti­sce che i comandi vengano eseguiti cor­ret­ta­men­te e offre i prepared statement: i se­gna­po­sto separano il comando SQL dagli input degli utenti, in modo che questi non vengano eseguiti come parte del comando.

Creare database e tabella

Per prima cosa creiamo in ph­p­MyAd­min un nuovo database con il nome testdb. All’interno di questo database definiamo una tabella chiamata users. Questa tabella contiene tre colonne: id per l’iden­ti­fi­ca­zio­ne univoca di ogni utente, username per il nome utente ed email per l’indirizzo e-mail. In SQL si presenta così:

CREATE TABLE users (
id INT AUTO_INCREMENT PRIMARY KEY,
username VARCHAR(50) NOT NULL,
email VARCHAR(100) NOT NULL
);
sql

Ope­ra­zio­ni nei database in PHP

Ora creiamo un file “crud.php” nella cartella “htdocs” di XAMPP. In questo esempio sta­bi­lia­mo una con­nes­sio­ne al database e mostriamo in­nan­zi­tut­to le ope­ra­zio­ni di base CREATE, READ, UPDATE e DELETE (CRUD):

<?php
// Establish database connection
$host = '127.0.0.1';
$db = 'testdb';
$user = 'root';
$pass = '';
$charset = 'utf8mb4';
$dsn = "mysql:host=$host;dbname=$db;charset=$charset";
$options = [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, // Make errors visible
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, // Data as array
];
try {
$pdo = new PDO($dsn, $user, $pass, $options);
} catch (PDOException $e) {
echo "Connection failed: " . $e->getMessage();
exit;
}
 
// CREATE: insert new user
$stmt = $pdo->prepare("INSERT INTO users (username, email) VALUES (:username, :email)");
$stmt->execute([
'username' => 'Max Mustermann',
'email' => 'max@example.com'
]);

// READ: fetch all users
$stmt = $pdo->query("SELECT * FROM users");
$users = $stmt->fetchAll();

// Output the user list
echo "<h2>User list</h2>";
foreach ($users as $user) {
echo "ID: " . $user['id'] . " – Name: " . htmlspecialchars($user['username']) . " – E-Mail: " . htmlspecialchars($user['email']) . "<br>";
}

// UPDATE: change a user's email
$stmt = $pdo->prepare("UPDATE users SET email = :email WHERE username = :username");
$stmt->execute([
'email' => 'max.mustermann@example.com',
'username' => 'Max Mustermann'
]);
echo "<p>The email address of Max Mustermann has been updated.</p>";

// DELETE: delete user
$stmt = $pdo->prepare("DELETE FROM users WHERE username = :username");
$stmt->execute([
    'username' => 'Max Mustermann'
]);
?>
php

Per prima cosa viene stabilita una con­nes­sio­ne al database con PDO. A questo scopo in­di­chia­mo host, nome del database, nome utente, password e set di caratteri. PDO ga­ran­ti­sce che i comandi SQL vengano eseguiti in modo sicuro e che gli errori risultino visibili.

Suc­ces­si­va­men­te mostriamo le quattro ope­ra­zio­ni fon­da­men­ta­li:

  • CREATE (in­se­ri­men­to di dati): con INSERT INTO inseriamo un nuovo utente. I se­gna­po­sto :username e :email ga­ran­ti­sco­no che gli input degli utenti vengano elaborati in modo sicuro.
  • READ (dati in lettura): con SELECT * FROM users re­cu­pe­ria­mo tutti i record esistenti. Con fetchAll() salviamo i risultati in un array e li mostriamo in un elenco chiaro e ordinato.
  • UPDATE (mo­di­fi­ca­re dati): con UPDATE possiamo cambiare l’indirizzo e-mail di un utente. Usiamo di nuovo dei se­gna­po­sto per inserire i valori in modo sicuro.
  • DELETE (eliminare dati): con DELETE FROM users WHERE username = :username eli­mi­nia­mo un de­ter­mi­na­to utente dal database. Il se­gna­po­sto :username ga­ran­ti­sce che l’input venga elaborato in modo sicuro, senza che un hacker possa ma­ni­po­la­re il database. In questo modo possiamo can­cel­la­re singoli record specifici senza in­fluen­za­re l’intera tabella.

Input dell’utente e trat­ta­men­to dei dati in sicurezza

Non appena PHP elabora dati inseriti dall’utente, si crea un rischio per la sicurezza. Le persone che visitano il sito possono ma­ni­po­la­re i campi di un modulo, inviare dati im­pre­vi­sti oppure tentare de­li­be­ra­ta­men­te di abusare di un’ap­pli­ca­zio­ne. Per questo motivo PHP mette a di­spo­si­zio­ne diverse funzioni con cui è possibile ve­ri­fi­ca­re, elaborare e salvare in modo sicuro i dati inseriti.

Ar­chi­via­re i dati in modo sicuro nei database: prepared statement

Una delle falle di sicurezza più comuni nelle ap­pli­ca­zio­ni PHP si verifica quando si lavora con i database. Se gli input degli utenti vengono inseriti di­ret­ta­men­te nelle query SQL, può ve­ri­fi­car­si una co­sid­det­ta SQL injection. In questo modo chi attacca inietta un proprio codice SQL.

Le di­chia­ra­zio­ni preparate (prepared statement) evitano questo problema separando in modo rigoroso il codice SQL dai dati degli utenti. PHP mette a di­spo­si­zio­ne a questo scopo l’in­ter­fac­cia di accesso al database PDO.

<?php
$stmt = $pdo->prepare("SELECT * FROM users WHERE username = :username");
$stmt->execute([
'username' => $username
]);
php

Il codice prepara una query al database per cercare tutti gli utenti nella tabella users il cui nome utente cor­ri­spon­de a un de­ter­mi­na­to valore. Invece di inserire il nome utente di­ret­ta­men­te nel comando SQL, viene usato il se­gna­po­sto :username, che viene riempito con un valore concreto solo al momento dell’ese­cu­zio­ne della query. In questo modo PHP separa il codice SQL dai dati degli utenti e impedisce che gli input possano ma­ni­po­la­re il comando.

Pro­teg­ge­re l’output: escaping

Non solo la me­mo­riz­za­zio­ne dei dati, ma anche la loro vi­sua­liz­za­zio­ne può essere pe­ri­co­lo­sa. Se le im­mis­sio­ni degli utenti vengono mostrate nel browser senza alcun filtro, può ve­ri­fi­car­si il co­sid­det­to cross-site scripting (XSS). In questo caso, nel browser di altri utenti viene eseguito codice dannoso. Per evitarlo, l’output viene ma­sche­ra­to. In PHP ciò avviene di solito con la funzione htmlspecialchars() e il testo viene mostrato, ma non in­ter­pre­ta­to come codice.

<?php
echo htmlspecialchars("<h1>Hello World!</h1>", ENT_QUOTES, 'UTF-8');
php
Immagine: Funzione PHP htmlspecialchars()
Se utilizzi html­spe­cial­chars(), il codice HTML viene in­ter­pre­ta­to come una semplice stringa.

Filtrare gli input utente: filter_input()

PHP offre con filter_input() la pos­si­bi­li­tà di ve­ri­fi­ca­re e ripulire i dati inseriti dall’utente già in fase di lettura. In questo modo è possibile ri­co­no­sce­re tem­pe­sti­va­men­te valori non validi o in­de­si­de­ra­ti. Un esempio semplice è la lettura di un indirizzo e-mail:

<?php
$email = filter_input(INPUT_POST, 'email', FILTER_VALIDATE_EMAIL);
php

Se l’input non è un indirizzo e-mail valido, la funzione re­sti­tui­sce false. Se il campo non è stato trasmesso affatto, il risultato è null. Controlla quindi entrambi i casi. In questo modo il codice può reagire in modo mirato prima di con­ti­nua­re a elaborare i dati.

Salvare le password in modo sicuro con password_hash()

Le password non devono mai essere me­mo­riz­za­te in chiaro. Anche una semplice cifratura non è suf­fi­cien­te. PHP mette a di­spo­si­zio­ne la funzione password_hash(), che esegue l’hashing sicuro delle password.

<?php
$hash = password_hash($password, PASSWORD_DEFAULT);
php

Al login suc­ces­si­vo, la password inserita viene ve­ri­fi­ca­ta con password_verify():

<?php
if (password_verify($password, $hash)) {
echo "Login successful";
}
php

Il valore effettivo della password non è mai più visibile. Anche in caso di vio­la­zio­ne del database, le password restano protette.

Pro­te­zio­ne dalla ma­ni­po­la­zio­ne dei moduli: token CSRF

Nei moduli esiste il rischio che vengano inviati all’insaputa delle persone che li usano. Per evitarlo, si uti­liz­za­no i co­sid­det­ti token CSRF. Si tratta di stringhe casuali di caratteri che vengono generate di nuovo a ogni apertura del modulo.

<?php
$_SESSION['token'] = bin2hex(random_bytes(32));
php

Questa riga genera un codice di sicurezza casuale, difficile da in­do­vi­na­re, e lo salva nella sessione corrente dell’utente. La funzione random_bytes(32) crea 32 byte casuali, cioè dati grezzi non di­ret­ta­men­te leggibili. Con bin2hex() questi dati grezzi vengono tra­sfor­ma­ti in una stringa ben leggibile composta da lettere e numeri. Il valore generato viene salvato in $_SESSION['token'] e usato in seguito per ve­ri­fi­ca­re se un modulo proviene davvero dalla stessa sessione.

Ca­ri­ca­men­to di file con convalida

Anche i ca­ri­ca­men­ti di file sono par­ti­co­lar­men­te sensibili e possono com­por­ta­re rischi per la sicurezza, poiché in questo modo file esterni arrivano sul server. Per questo motivo è sempre ne­ces­sa­rio con­trol­la­re il tipo di file e la di­men­sio­ne del file.

Un esempio semplice per il controllo delle di­men­sio­ni di un file potrebbe essere il seguente:

<?php
if ($_FILES['upload']['size'] > 1000000) {
echo "File is too big.";
}
php

Il codice verifica quanto è grande il file caricato e lo confronta con un valore massimo pre­fis­sa­to di 1.000.000 byte. Se il file è più grande del con­sen­ti­to, viene vi­sua­liz­za­to un messaggio di errore e il ca­ri­ca­men­to può essere rifiutato. In questo modo si impedisce che file troppo grandi vengano caricati sul server. Inoltre, si dovrebbe ve­ri­fi­ca­re che si tratti davvero del tipo di file atteso, ad esempio un’immagine. I file non do­vreb­be­ro mai essere me­mo­riz­za­ti sul server in modo ese­gui­bi­le senza essere con­trol­la­ti.

Vai al menu prin­ci­pa­le