Imparare a programmare in PHP: tutorial per chi è agli inizi
PHP è uno dei linguaggi di programmazione più comuni per la programmazione lato server. Con il passare del tempo, è diventato una parte indispensabile di buona parte dei moderni siti web e delle tecnologie internet. Ma imparare questo linguaggio può essere una grande sfida per chi è alle prime armi. Con questo tutorial su PHP ti mostriamo le basi di questo popolare linguaggio di programmazione, compresi i suoi operatori, i cicli e le funzioni più importanti.
Riassunto
- Per eseguire gli esempi ti serve un server web con interprete PHP, ad esempio tramite XAMPP, il server integrato di PHP o Docker.
- Le basi di PHP comprendono sintassi,
echo, variabili, tipizzazione rigorosa, operatori di concatenazione e calcolo con le variabili. - Con le superglobali
$_GETe$_POSTtrasmetti i dati, conif,matche i cicli controlli il flusso del programma. - Altri capitoli mostrano le operazioni sui file, la programmazione orientata agli oggetti e il codice pulito con Composer e namespace.
- Per concludere, il tutorial presenta un esempio PDO per i database e misure di protezione come i prepared statement, l’escaping dell’output e l’hashing delle password.
Tutorial su PHP: una guida completa
Il nostro tutorial si rivolge principalmente a chi è alle prime armi. Per alcuni esempi, tuttavia, è utile avere una conoscenza di base dello sviluppo web moderno e del linguaggio HTML. I requisiti per riprodurre gli esempi illustrati in questo articolo sul tuo computer sono i seguenti:
- Un server web con interprete PHP
- Avere installato PHP
- Un browser web
- Un editor di testo
XAMPP
Come server, consigliamo l’ambiente di test locale XAMPP, fornito gratuitamente da Apache Friends per i sistemi operativi Windows, Linux e macOS. XAMPP è un server di test puro. Il pacchetto software offre la possibilità di configurare un ambiente di test completo per script, pagine HTML e fogli di stile in pochissimo tempo. Tuttavia, il funzionamento sicuro come server web su internet non è garantito. Le istruzioni dettagliate per l’installazione sono disponibili nel nostro tutorial su XAMPP.
- Disponibilità garantita al 99,99%
- Dominio, SSL ed e-mail inclusi
- Assistenza 24/7 in lingua italiana
Server integrato PHP
A partire dalla versione 5.4, PHP include un server di sviluppo integrato, particolarmente adatto per test semplici e per l’apprendimento. Questo server integrato non richiede alcun software server aggiuntivo come Apache o NGINX. L’unico requisito è avere installata una versione di PHP sul tuo sistema. Successivamente puoi avviare il server direttamente dalla riga di comando nella directory del progetto:
php -S localhost:8000bashPHP rende quindi disponibili i file nella cartella corrente all’indirizzo http://localhost:8000 nel browser web. Il server integrato è adatto soprattutto per i primi esperimenti con PHP, piccoli script di test o per ricostruire rapidamente esempi di codice.
Docker e Docker Compose
Un’alternativa un po’ più avanzata è l’utilizzo di Docker. Docker consente di incapsulare gli ambienti di sviluppo nei cosiddetti container. In questo modo è possibile configurare server web, PHP e database esattamente come verranno eseguiti in seguito nell’ambiente di produzione. Per i progetti PHP si utilizza spesso Docker-Compose, per avviare più servizi contemporaneamente. L’intera configurazione viene definita in un file (“docker-compose.yml”) e può essere avviata con un unico comando.
Basi di PHP: la sintassi del linguaggio di scripting
Una volta configurato il server web locale, ad esempio utilizzando XAMPP, è opportuno verificare se PHP è stato installato correttamente ed è pronto a eseguire gli script. Gli script sono programmi che non vengono preventivamente compilati in codice binario, ma vengono eseguiti da un interprete. Aprendo il tuo editor di testo preferito, puoi creare il seguente script PHP:
<?php
phpinfo();
?>phpGli script PHP sono sempre strutturati 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 istruzioni. Nell’esempio, si tratta dell’istruzione alla funzione phpinfo(). La maggior parte delle funzioni PHP richiede uno o più parametri racchiuso tra parentesi tonde; per phpinfo() questi sono opzionali. Ogni istruzione termina con un punto e virgola (;). Per chiudere l’ambiente di script, si usa il tag PHP di chiusura: ?>, che è facoltativo 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 utilizzando l’ambiente di test XAMPP, salva “test.php” nella directory XAMPP sotto “htdocs” (C:\xampp\htdocs).

Ora puoi accedere al file di esempio tramite il seguente URL nel browser web: http://localhost/test.php. Se stai utilizzando un server web diverso o una configurazione individuale del software XAMPP, seleziona l’URL in base al rispettivo 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 utilizzato recupererà il file nella giusta directory. L’estensione .php informa che il file contiene codice PHP. A questo punto entra in funzione l’interprete 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’interprete è in grado di eseguire il codice PHP e di generare l’output HTML che viene inviato dal server web al browser web.
La funzione phpinfo() è la forma abbreviata del valore standard phpinfo(INFO_ALL). Questa restituisce informazioni dettagliate sulla configurazione 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 interpretarlo.
“Hello World!”: come creare un output di testo tramite echo
Una volta che l’installazione di PHP è andata a buon fine, è il momento di scrivere il primo script. L’istruzione PHP echo si presta bene a questo scopo. Diversamente da phpinfo(), echo non è una funzione. Si tratta piuttosto di un costrutto linguistico che consente di produrre una stringa successiva come testo.
I costrutti linguistici sono istruzioni utilizzate in PHP per controllare il processo di programmazione. Oltre a echo, i costrutti linguistici includono istruzioni come if, for, do, include, return, exit o die. A differenza delle funzioni, quindi, in questo caso non sono necessarie le parentesi.
Crea un nuovo file PHP per il tuo primo script e scrivici il seguente codice:
<?php
echo 'Hello World!';phpIl tag di apertura <?php apre un ambiente di script. Seguono il costrutto linguistico echo e la stringa Hello World! racchiusa in virgolette singole. Fai attenzione al punto e virgola dopo l’istruzione. Al posto di “Hello World!” puoi usare qualsiasi testo. Poiché si tratta di un file PHP puro, abbiamo rinunciato al tag PHP di chiusura.
Il tag PHP di chiusura ?> non deve essere utilizzato nei file che contengono solo PHP. In questo modo si possono evitare righe vuote accidentali o caratteri invisibili alla fine del file, che potrebbero 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 trasferito correttamente, nella finestra del browser dovrebbe apparire la stringa utilizzata:

Qualsiasi testo emesso con echo può essere contrassegnato con tag HTML, se necessario. Questi tag vengono poi interpretati dal browser web in base alle specifiche HTML. Fai una prova, ad esempio con il seguente script:
<?php
echo '<h1>Hello World!</h1>
<p>This is my first PHP page.</p>';phpQuando viene visualizzato nel browser web, il risultato dell’esecuzione dello script appare come segue.

La stringa “Hello World!” compresa nei tag <h1> viene interpretata dal browser web come primo titolo. È seguita da un’interruzione di riga automatica e dal paragrafo di testo <p>.
A seconda delle esigenze, echo può essere usato con virgolette singole (') o doppie ("). Se vogliamo emettere solo testo, non fa alcuna differenza la scelta delle virgolette. Ma le cose cambiano quando entrano in gioco le variabili PHP.
Le variabili
Il costrutto linguistico echo è molto più di un semplice output di testo. Infatti, può essere implementato efficacemente anche senza PHP, su una base di HTML. Il vero valore aggiunto di echo si basa sul fatto che l’istruzione consente di generare testo dinamicamente con l’aiuto di variabili.
Le variabili si presentano ad esempio nella forma seguente: $example.
Ciascuna variabile è costituita dal simbolo del dollaro ($) seguito dal nome della variabile. Le variabili sono utilizzate 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 | Descrizione |
|---|---|
| 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 programmazione, la virgola decimale si scrive come punto (.). La precisione è di circa 14 cifre significative; vengono conteggiate tutte le cifre, non solo quelle dopo la virgola. |
| Boolean | Le variabili booleane sono il risultato di un’operazione logica e presentano solo due valori: TRUE (vero) e FALSE (falso). Questo tipo di variabile viene utilizzato, ad esempio, per lavorare con le condizioni. |
| Array | Un array è una variabile che può contenere diversi elementi. È quindi un raggruppamento di diversi dati strutturati 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 utilizzato nella programmazione orientata agli oggetti. Nel nostro tutorial PHP per chi è alle prime armi, le variabili di tipo object sono state escluse. |
| NULL | Il valore NULL rappresenta una variabile senza valore, l’unico valore possibile per le variabili di tipo NULL. |
| Resource | Resource è una variabile speciale che contiene un riferimento a risorse esterne, ad esempio un file aperto, una connessione al database o un socket. Le risorse sono gestite direttamente da PHP. Nel nostro tutorial PHP tralasciamo queste variabili. |
La gestione centralizzata dei contenuti viene solitamente effettuata con l’aiuto di sistemi di database. È tuttavia possibile definire i valori delle variabili anche direttamente nello script. Questo tipo di assegnazione avviene secondo il seguente schema:
$example = "value";phpIl caratteristico 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 virgolette. I valori delle variabili di tipo integer e float sono indicati senza virgolette (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 restrizioni:
- Ogni variabile deve iniziare con il simbolo del dollaro.
- Il nome di una variabile è una successione di caratteri a piacimento 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 (
$example1o$_example), mai con una cifra (errato:$1example). - Il PHP è case sensitive. Il linguaggio di scripting fa quindi distinzione tra lettere maiuscole e minuscole (
$example≠$Example). - Il nome di una variabile non deve contenere spazi o interruzioni di riga (errato:
$example 1). - Le stringhe riservate da PHP per altri scopi non possono essere utilizzate come variabili definite dall’utente (ad esempio,
$this).
Approfondiamo 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>";phpIl tag PHP di apertura è seguito dalla definizione della variabile: per $author deve essere utilizzato il valore “John Doe”. Quando lo script viene eseguito, la variabile $author viene sostituita dal valore “John Doe” ogni volta che viene menzionata nell’ambiente di script. Nell’immagine seguente vediamo come si presenterebbe il browser web.

Se c’è un errore e la pagina web non proviene da John Doe, ma dal suo collega Max Mustermann, per risolvere il problema è sufficiente modificare la variabile con il nome $author. Ciò si rivela particolarmente efficace quando una variabile ricorre più volte all’interno di uno script. In tal caso, la correzione deve essere effettuata 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 modificati, non occorre apportare le modifiche manualmente su ogni singola sottopagina del progetto web. Piuttosto, basterà aggiornare la voce corrispondente nel database. Così, la revisione viene applicata automaticamente a tutte le pagine web che includono i dati corrispondenti come variabili.
Se una variabile viene definita più volte all’interno di uno script, la nuova definizione sovrascrive la precedente. Un elemento echo successivo restituisce 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>";phpNell’esempio di codice, il valore “John Doe” viene prima assegnato alla variabile $author e poi sostituito con il valore “Max Mustermann”.

Passiamo ora alle virgolette. A differenza delle stringhe, le variabili singole non devono essere racchiuse tra virgolette:
<?php
$author = "John Doe";
echo $author;phpQuesto è vero a meno che la variabile non debba essere utilizzata all’interno di una stringa. In tal caso, infatti, vanno usate le doppie virgolette (“), che segnalano all’interprete PHP di cercare nella stringa le variabili che potrebbero dover essere sostituite dai valori a esse associati. Le stringhe racchiuse tra virgolette singole (’) vengono interpretate e rese come informazioni 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>';phpLa variabile in questo caso quindi non viene interpretata, ma semplicemente restituita come testo.

Forse ti starai chiedendo cosa succede se ometti del tutto le virgolette? In questo caso, PHP segnala un errore sintattico.
Tipizzazione rigorosa con declare(strict_types=1)
Per impostazione predefinita PHP cerca di convertire automaticamente tra loro tipi di dati diversi. In questo modo ci si destreggia tra diversi tipi e può succedere che i valori errati vengano elaborati ulteriormente senza essere notati. Con la direttiva declare(strict_types=1); è possibile disattivare in modo mirato questo comportamento. PHP controlla quindi in modo rigoroso, durante le chiamate di funzione, se gli argomenti passati e i valori di ritorno corrispondono ai tipi di variabile dichiarati. 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);phpNell’esempio, una funzione PHP chiamata add() accetta esclusivamente valori interi. Mentre la chiamata con 2 e 3 funziona senza problemi, la seconda chiamata genera un errore, perché la stringa "2" non viene convertita automaticamente in un numero intero. Grazie alla tipizzazione rigorosa, problemi di questo tipo vengono individuati precocemente, il che migliora sensibilmente la manutenibilità e l’affidabilità del codice PHP.
Messaggi di errore e mascheramento
Se si verificano errori sintattici, il codice PHP non risulta valido per cui l’interprete PHP emette un messaggio di errore. Può capitare, ad esempio, quando l’istruzione echo viene utilizzata con una stringa senza virgolette:
<?php
echo Hello World!;phpNella maggior parte dei casi, i messaggi di errore contengono informazioni sul punto in cui si è verificato l’errore e forniscono quindi importanti indicazioni per la sua risoluzione. Puoi comunque visualizzare i messaggi nel log di XAMPP in C:\xampp\logs\php_error_log.

Nell’esempio presente, è stato rilevato un errore nella riga 2 del codice del programma, proprio dove abbiamo omesso le virgolette a scopo dimostrativo.
Si verificano errori sintattici anche quando vuoi visualizzare 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’interprete che il carattere è stato svincolato dalla sua funzione originaria. Nel caso degli apici semplici hai a disposizione due possibilità: puoi racchiudere una stringa con apici semplici tra virgolette doppie oppure mascherarli anteponendo un backslash (operazione detta anche “escape”):
<?php
echo '\'Hello World!\' ';php
È possibile anche la combinazione di virgolette singole e doppie:
<?php
echo " 'Hello World!' ";phpTuttavia, non è ammessa la seguente scrittura:
<?php
echo ' 'Hello World!' ';phpGli spazi tra le virgolette sono stati inseriti negli esempi per facilitare la lettura.
Operatori di concatenazione
Se in uno script PHP vogliamo produrre contemporaneamente diverse variabili, possiamo implementare 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È sufficiente scrivere entrambe le variabili insieme al resto del testo da produrre nella stringa racchiusa tra doppie virgolette. PHP riconosce automaticamente le variabili dal simbolo del dollaro ($) e inserisce i valori corrispondenti.

Tra le persone che si occupano di programmazione, tuttavia, una procedura di questo tipo è considerata un lavoro poco pulito. Il dogma è che le variabili non devono far parte della stringa. Una delle ragioni è che molti linguaggi di programmazione prescrivono questa separazione. Ma soprattutto, anche PHP richiede la separazione tra stringa e variabile quando si lavora con funzioni o variabili più complesse. Per questo motivo, è consigliabile implementare questa separazione in modo coerente anche nell’output di testo semplice, anche se in questo caso non sarebbe strettamente necessario.
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 concatenazione (.).
Se è stato programmato in modo “pulito”, il codice dell’esempio precedente 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>';phpSi tratta quindi di tre stringhe e due variabili che vengono concatenate 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 concatenazione unisce stringhe o variabili senza spazi. Se desideri aggiungere uno spazio, devi inserirlo all’interno delle virgolette nella stringa, come nell’esempio.

L’operatore di concatenazione viene utilizzato nella programmazione 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;phpPer estendere il valore di una variabile, definiscila nuovamente, ma inserisci l’operatore di concatenazione prima del segno di uguale. Si tratta della consueta forma abbreviata per $example = $example . 'World'.
PHP aggiungerà il nuovo valore a quello definito in precedenza. Se desideri uno spazio tra i due valori, scrivilo alla fine della prima stringa, come nell’esempio.

Come incorporare PHP in HTML
Sostanzialmente, l’interprete PHP è interessato 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’interprete 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. È importante accertarsi che i documenti HTML contenenti codice PHP siano salvati come file PHP. Altrimenti, il documento non verrà preprocessato dall’interprete PHP, ma consegnato direttamente al browser web, con il risultato che il codice del programma apparirà sul sito web sotto forma di testo.
Si può quindi pensare all’interprete PHP come al collega pigro del server web, che lavora solo quando gli viene chiesto esplicitamente 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 salviamola con l’estensione .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>htmlAggiungiamo ora uno script PHP al documento HTML. Assicurati 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>htmlNell’esempio, abbiamo combinato il costrutto linguistico 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 desiderato 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’interprete PHP esegue prima lo script e scrive l’ora corrente come testo nel documento HTML. Questo viene poi consegnato dal server web e visualizzato come pagina web nel browser.

La funzione di commento di PHP
Come il codice HTML, anche PHP può essere commentato a piacere. I commenti nel codice sorgente vengono ignorati dall’interprete PHP, a condizione che siano stati marcati rispettando la sintassi. Il linguaggio di scripting fornisce tre diverse alternative a questo scopo.
Se desideri contrassegnare un’intera riga come commento e quindi escluderla dall’interpretazione, puoi servirti dell’hashtag (#) o di due barre oblique consecutive. Nell’esempio di codice seguente sono state utilizzate 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!phpGli editor di testo o le IDE con evidenziazione della sintassi mettono in risalto i commenti con colori differenti. I passaggi di testo contrassegnati come commento nell’ambiente di script non arrivano affatto al browser web, a differenza dei commenti HTML, perché vengono già ignorati durante l’esecuzione dello script dall’interprete PHP.
Inoltre, è possibile inserire commenti che si estendono su più righe. A tale scopo, contrassegna 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>';phpAnche i commenti contrassegnati in questo modo non vengono presi in considerazione dall’interprete e quindi non compaiono sul sito web.

Chi programma ricorre ai commenti per strutturare il codice sorgente dei propri script, lasciare appunti per una successiva modifica o aggiungere informazioni interne alla creazione, come l’autrice o l’autore e la data. I commenti sono facoltativi e dovrebbero essere utilizzati con parsimonia per garantire una buona leggibilità del codice sorgente.
Calcolo con le variabili
In questo tutorial dedicato al linguaggio PHP abbiamo già incontrato le variabili. A queste sono stati assegnati principalmente valori string (cioè stringhe di caratteri). Ora ci occuperemo di variabili che rappresentano numeri interi (integer) o numeri in virgola mobile (float).
Se le variabili memorizzano valori numerici, PHP offre la possibilità di eseguire calcoli con esse. Cominciamo con la semplice addizione di due numeri interi:
<?php
$number1 = 237;
$number2 = 148;
$result = $number1 + $number2;
echo "result: " . $result;phpPer prima cosa assegniamo i numeri interi 237 e 148 alle variabili $number1 e $number2 e poi definiamo una variabile $result. Questa variabile ha lo scopo di memorizzare la somma delle due variabili. Per farlo, ci serviamo dell’**operatore aritmetico + **(più). Infine, il risultato dell’addizione viene visualizzato come testo utilizzando il costrutto linguistico echo. Non è necessario usare le virgolette quando si assegnano valori numerici alle variabili.

Il seguente esempio di codice mostra una selezione di calcoli matematici effettuabili lato server con PHP. Gli operatori PHP utilizzati corrispondono per lo più ai simboli matematici standardizzati.
| Operatore aritmetico | Operazione | Risultato |
|---|---|---|
$number1 + $number2 |
Addizione | Somma di $number1 e $number2 |
$number1 - $number2 |
Sottrazione | Differenza di $number1 e $number2 |
$number1 * $number2 |
Moltiplicazione | 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 />";phpL’output è il seguente:

Per i calcoli complessi, è possibile combinare le varie operazioni aritmetiche in un unico script:
<?php
$number1 = 10;
$number2 = 5;
$result = 2 * $number1 + 5 * $number2 - 3 * sqrt(81);
echo "Result: " . $result;phpL’interprete 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 classificazione standard degli operatori matematici: il punto precede il trattino. L’istruzione echo produce il risultato come stringa per il browser web.
In PHP, anche i termini tra parentesi sono interpretati 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
Come tutti i comuni linguaggi di programmazione, anche PHP supporta gli operatori per incrementare o decrementare i valori numerici del valore 1. Si fa una distinzione tra l’operatore di pre-incremento, l’operatore di pre-decremento, l’operatore di post-incremento e l’operatore di post-decremento.
| Operazione | Operatore | Risultato |
|---|---|---|
| Pre-incremento | ++$number |
L’operatore ++ incrementa il valore della variabile $number. Di conseguenza il valore aumenta di 1. Il risultato viene emesso come nuovo valore di $number. |
| Pre-decremento | --$number |
L’operatore -- decrementa il valore della variabile $number. Di conseguenza il valore decrementa di 1. Il risultato viene emesso come nuovo valore di $number. |
| Post-incremento | $number++ |
Il valore attuale di $number viene prima emesso e poi incrementato del valore 1. |
| Post-decremento | $number-- |
Il valore attuale di $number viene prima emesso e poi decrementato del valore 1. |
Per dimostrare le operazioni aritmetiche con gli operatori di incremento o decremento, utilizziamo l’esempio del pre-incremento. Il seguente script incrementa 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;phpAumentando di 1 il valore 0, si ottiene il risultato 1.

Per calcolare il pre-decremento della variabile $number, ricorriamo agli stessi script, ma scambiando l’operatore di pre-incremento (++) con quello di pre-decremento (--):
<?php
$number = 0;
$result = --$number;
echo "Result: " . $result;phpIn questo modo si decrementa 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 esemplificato 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>';phpIn entrambi i casi si ottiene lo stesso risultato. Nel caso del pre-incremento, il valore x viene incrementato prima dell’output alla riga 3, mentre nel caso del post-incremento dopo l’output alla riga 5.

Tipi scalari e union
PHP permette di assegnare alle variabili, ai parametri di funzione e ai valori di ritorno i cosiddetti tipi scalari. Tra questi rientrano, tra gli altri, int, float, string e bool. Grazie all’indicazione esplicita del tipo si stabilisce quale tipo di valori una funzione si aspetta e restituisce. Questo aumenta la leggibilità del codice e aiuta a individuare tempestivamente errori tipici.
<?php
declare(strict_types=1);
function hi(string $name): string {
return "Hello " . $name;
}phpIn questo esempio, la funzione personalizzata hi() si aspetta una stringa come parametro e restituisce anch’essa una stringa. Se viene passato un altro tipo di dato, PHP segnala un errore. In alcune situazioni, però, una funzione deve accettare più di un tipo di dato. A questo scopo PHP mette a disposizione i cosiddetti tipi union. Questi permettono di definire più tipi possibili, separati dal carattere pipe |:
<?php
declare(strict_types=1);
function formatId(int|string $id): string {
return "ID: " . $id;
}phpLa funzione formatId() accetta qui sia numeri interi sia stringhe come parametro. Altri tipi di dato non sono consentiti. I tipi union permettono quindi firme di funzione flessibili, ma comunque controllate.
Le variabili superglobali $_GET e $_POST
Ora conosci le basi di PHP, sai come gestire le variabili, puoi concatenarle e utilizzarle per eseguire calcoli. È giunto il momento di mostrarti perché le variabili sono un concetto centrale nella programmazione degli script.
Una funzione importante dei linguaggi di scripting è la capacità di valutare gli input dell’utente e di trasferire i valori a un altro script. Per il trasferimento dei dati, PHP ricorre alle variabili di sistema superglobali $_GET e $_POST, variabili predefinite e disponibili in tutti gli ambiti di validità. In qualità di array associativi, $_GET e $_POST memorizzano un insieme di variabili sotto forma di stringhe in una variabile superglobale.
Possiamo pensare agli array PHP come a un comò con diversi cassetti. Ciascuno di questi cassetti offre la possibilità di memorizzare dati. Per sapere anche in futuro che cosa contiene ogni cassetto, li etichettiamo 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 indicizzati, a ogni cassetto viene assegnato un indice sotto forma di numero, in un array associativo i cassetti si etichettano con una chiave sotto forma di stringa.
Le variabili superglobali $_GET e $_POST contengono una serie di variabili sotto forma di chiavi che consentono di ottenere i valori associati a tali chiavi. Andiamo a esaminarle nel dettaglio.
Trasmissione dei dati tramite $_GET
La superglobale $_GET rappresenta un array di variabili che vengono trasmesse in uno script PHP tramite un URL.
Se ti capita di frequentare 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 utilizzato per creare un sito web dinamico. Questo file normalmente contiene codice HTML e PHP, nonché riferimenti a file di template e fogli di stile esterni: in breve, tutto ciò che è necessario per visualizzare un sito web.
L’aggiunta id=1 dopo il punto interrogativo (?) indica che probabilmente abbiamo a che fare con un sito web dinamico. Si tratta di una stringa di ricerca basata sul protocollo HTTP che contiene una variabile (id) e un valore (1) collegati da un segno di uguale (=). I parametri URL di questo tipo vengono utilizzati, ad esempio, per creare pagine web dinamiche, caricare contenuti da un database o richiamare un template.
I siti web dinamici consentono di separare i contenuti dalla veste grafica. Il file “index.php” comprende quindi tutte le informazioni sulla struttura del sito web, ma deve ancora essere riempito con i contenuti. Tipicamente, questi sono memorizzati in un database e possono essere richiamati tramite i parametri della stringa di ricerca HTTP. Nel nostro esempio, l’URL trasmette a “index.php” il parametro id=1. Questo parametro stabilisce 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 discussione e in un negozio online di un prodotto.
Se un URL contiene più di un parametro, questi vengono collegati con una e commerciale (&).
www.blog-esempio.it/index.php?page=article&id=1
Per illustrare l’uso di $_GET con un esempio di codice, possiamo anche fare a meno di un database. Nello script seguente, utilizziamo la superglobale $_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 . "!";phpL’esecuzione dello script avviene tramite il seguente URL:
localhost/hello.php?firstname=John&lastname=Doe
In questo modo trasmettiamo i parametri firstname=John e lastname=Doe. I valori vengono emessi come prima con l’aiuto del costrutto linguistico echo.

La trasmissione dei dati tramite $_GET comporta necessariamente 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 collegamenti ipertestuali. Inoltre, l’utente ha la possibilità di creare URL comprensivi di stringa di ricerca sotto forma di segnalibro nel browser.
Il fatto che il parametro GET venga eseguito nel testo in chiaro nell’URL disqualifica questo metodo per la trasmissione 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.
Queste restrizioni possono essere aggirate con il metodo HTTP POST. I dati trasferiti si trovano nella superglobale $_POST.
Trasmissione dei dati tramite $_POST
I metodi HTTP GET e POST si differenziano per il modo in cui i dati vengono trasmessi: mentre nel metodo GET i dati da trasmettere vengono inoltrati come parametro dell’URL, nel corpo (body) di una richiesta HTTP i dati vengono trasferiti tramite $_POST. Ciò consente di trasmettere anche grandi quantità di dati da uno script a un altro.
Uno dei campi di applicazione principali del metodo HTTP POST è la trasmissione dati dei moduli HTML. Lo dimostriamo con l’esempio della registrazione a una newsletter.
Per prima cosa, è necessario 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>htmlPer creare i moduli viene utilizzato l’elemento HTML <form>. Ciò comprende due attributi nel tag iniziale: method e action. Con l’attributo method si definisce il metodo di trasmissione, 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 successivi. Il codice usato da esempio rappresenta 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 destinatario dei dati.
Per illustrare il trasferimento dei dati tramite $_POST, utilizziamo un semplice script per la valutazione dei dati del modulo che salva i valori trasferiti come variabili PHP e li restituisce 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 . ".";phpSalva 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 visualizzare l’interfaccia interattiva del tuo modulo HTML.

Inserisci le credenziali di accesso e premi il pulsante di invio per trasferire le variabili da uno script all’altro. Dopo aver confermato l’inserimento in “page1.php”, avverrà immediatamente il reindirizzamento a “page2.php”. La finestra del browser mostrerà il risultato dell’esecuzione dello script in base ai dati trasferiti.

Gli input dell’utente raccolti attraverso i campi di input di “page1.php” vengono recuperati da “page2.php” attraverso il seguente schema:
$_POST["Nome del campo di input"]
Di conseguenza le righe $firstname = $_POST["firstname"] aprono l’input nel campo firstname e lo salvano nella variabile $firstname. La variabile $firstname può nuovamente essere emessa tramite echo come stringa.
Il costrutto if e gli operatori di confronto in PHP
Finora abbiamo definito le variabili, le abbiamo trasferite da uno script all’altro e le abbiamo prodotte come stringhe. Nel prossimo passo, imparerai a collegare l’esecuzione di frammenti di codice a determinate condizioni.
Il costrutto linguistico if dà la possibilità di scrivere script in modo che le istruzioni diventino effettive solo quando viene soddisfatta una condizione definita dall’utente, come ad esempio l’inserimento di una password corretta.
Le condizioni sono definite in PHP secondo la seguente struttura di base:
<?php
if(expression)
{
statement;
}phpIl codice va letto nel modo seguente: la dichiarazione statement viene eseguita solo se la condizione contenuta nell’espressione (expression) è soddisfatta. Una condizione è sempre soddisfatta se il costrutto if restituisce il risultato TRUE (vero). In caso contrario, viene considerata FALSE (falsa). In questo caso, l’istruzione viene saltata.
Solitamente il costrutto if verifica che il valore di una variabile corrisponda a quello che è stato definito nella condizione. Questa struttura di controllo viene normalmente realizzata sulla base di operatori di confronto.
Operatori di confronto
Gli operatori di confronto vengono utilizzati nella formulazione di condizioni per mettere in correlazione logica due argomenti, che possono essere valutati come veri (TRUE) o falsi (FALSE). Quando gli operatori di confronto vengono utilizzati nelle strutture di controllo PHP, questi vengono applicati su due variabili nell’espressione di un costrutto if:
if ($a == $b)
{
statement;
}phpLa struttura di controllo può dunque essere letta in questo modo: se la variabile $a è uguale alla variabile $b, verranno eseguite le istruzioni definite nella dichiarazione.
Gli operatori di confronto di PHP si basano sul linguaggio di programmazione C. Per quanto possano apparire simili ai classici simboli matematici nella loro notazione, si differenziano da questi ultimi per molti aspetti, a volte anche piuttosto sostanziali. Nella tabella seguente è riportata una panoramica.
| Operatore di confronto | Descrizione | Condizione |
|---|---|---|
== |
è uguale | La condizione è soddisfatta se $a e $b hanno lo stesso valore. |
=== |
è identico | La condizione è soddisfatta se $a e $b hanno lo stesso valore e appartengono allo stesso tipo di dati. È possibile illustrare questo aspetto con un esempio in cui un integer (1) viene confrontato con una stringa (“1”): 1 == "1" diventa TRUE e 1 === "1" diventa FALSE Per le condizioni che richiedono l’uguaglianza di due variabili, è meglio utilizzare sempre l’operatore relazionale === (è identico). |
!= |
è diverso | La condizione è soddisfatta quando $a e $b hanno valori differenti. |
!== |
non identico | La condizione è soddisfatta se $a e $b hanno valori non uguali o appartengono a tipi di dati diversi. |
< |
è minore di | La condizione è soddisfatta se il valore di $a è minore del valore di $b. |
> |
è maggiore di | La condizione è soddisfatta se il valore di $a è maggiore del valore di $b. |
<= |
è minore o uguale | La condizione è soddisfatta se il valore di $a è minore del valore di $b o se $a e $b hanno lo stesso valore. |
>= |
è maggiore o uguale | La condizione è soddisfatta 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 illustrare questa struttura di controllo. Vengono confrontati due integer. L’operatore di confronto è < (è minore di):
<?php
$number1 = 10;
$number2 = 20;
if ($number1 < $number2) {
echo "The condition is met";
}phpDefiniamo le variabili $number1 e $number2 e assegniamo loro i valori 10 e 20. Quindi impostiamo una condizione: se $number1 è minore di $number2, viene emessa la stringa elencata nell’istruzione echo.
Il risultato dell’esecuzione dello script contiene la risposta: 10 è minore di 20. Il costrutto if restituisce il risultato TRUE. La condizione è soddisfatta.

Se desideri definire istruzioni da eseguire non appena una condizione non è soddisfatta, aggiungi il costrutto linguistico else alla struttura di controllo if per creare un’istruzione condizionale if else in PHP:
<?php
if(Condition a)
{
statement b;
}
else
{
statement c;
}phpQuesto script controlla anche se la condizione a restituisce il risultato TRUE o FALSE. Se la condizione a è soddisfatta, viene eseguita l’istruzione b. Se la condizione a non è soddisfatta (FALSE), l’istruzione b viene saltata e al suo posto viene eseguita l’istruzione c.
Estendiamo il nostro script con il costrutto else e sostituiamo 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";
}phpQuesta volta il costrutto if restituisce il risultato FALSE. Il valore della variabile $number1 non è uguale al valore della variabile $number2. La condizione non è soddisfatta. Pertanto, non viene eseguita l’istruzione definita sotto if, bensì quella definita sotto else.

Se l’esecuzione di una parte di codice è collegata all’uguaglianza di due valori, in PHP viene utilizzato un doppio segno di uguale (==). Il segno di uguale semplice (=) va utilizzato esclusivamente nell’assegnazione di valori a variabili.
La negazione delle condizioni avviene mediante un punto esclamativo (!) anteposto.
<?php
$number1 = 10;
$number2 = 20;
if ($number1 == $number2)
{
echo "The numbers are equal.";
}
if (!($number1 == $number2))
{
echo "The numbers are not equal.";
}phpL’esempio mostra la condizione $number1 == $number2 e la loro negazione. !($number1 == $number2) corrisponde a ($number1 != $number2).
Un’applicazione pratica di if ed else è, per esempio, la richiesta di password basata su un modulo HTML. Simuliamo ancora una volta questo caso utilizzando 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>htmlLa struttura corrisponde al modulo già creato. Questa volta, però, è sufficiente un solo campo di input: la richiesta della password. Come in precedenza, l’input dell’utente viene trasmesso allo script “page2.php”.
Adattiamo il codice seguente in modo che l’inserimento della password sia abbinato a una password memorizzata:
<?php
$password = $_POST["password"];
if($password=="qwertz123")
{
echo "The password was correct";
}
else
{
echo "The password was incorrect";
}phpIl codice si legge come segue: per prima cosa, nella riga 2 assegniamo un valore alla variabile $password, che recuperiamo tramite il metodo HTTP POST. Quindi definiamo la seguente struttura di controllo: la struttura if nella riga 3 serve a verificare se il valore della variabile $password corrisponde alla stringa qwertz123. In caso affermativo, viene emessa la stringa “The password was correct” (La password è corretta). Se if restituisce il risultato FALSE, nella riga 7 viene utilizzato 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.

Il browser presenta la visualizzazione web del modulo HTML per la richiesta della password. Accettiamo la richiesta, inseriamo la password “qwertz123” definita nello script “page2.php” e facciamo clic sul pulsante di invio.

Il browser web reindirizza automaticamente a “page2.php”. In background, la struttura di controllo if confronta il nostro input con la password memorizzata e giunge al seguente verdetto: “qwertz123 == qwertz123 è TRUE”, emettendo così la stringa “The password was correct”. Verifica personalmente cosa succede digitando una password diversa nel campo di immissione.
Operatori logici
Le condizioni definite utilizzando gli operatori di confronto nell’espressione del costrutto if possono essere collegate ad altre condizioni nella stessa espressione, se necessario. PHP si basa sugli operatori logici AND e OR.
| Alias simbolico | Operatore | Descrizione |
|---|---|---|
&& |
AND |
Entrambe le condizioni associate all’operatore devono essere TRUE. |
|| |
OR |
Solo una delle due condizioni associate all’operatore deve essere TRUE. |
Per collegare le condizioni, PHP fornisce operatori logici con elementi di unione vincolanti e poco vincolanti. Utilizzando solo una delle due notazioni, non si noterà alcuna differenza nella pratica. Combinando entrambe le notazioni, si noterà che && e || vincolano più strettamente di AND e OR. Questo è paragonabile all’ordine di precedenza degli operatori matematici (ad esempio, punto prima della linea: * è più vincolante rispetto a +).
Un esempio pratico è fornito dalla richiesta di password. Di norma, i dati di login comprendono una password segreta e un nome utente. Solo se entrambe le voci corrispondono ai dati memorizzati nel sistema, il login va a buon fine.
Riapriamo il modulo di richiesta della password in “page1.php” e aggiungiamo 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>htmlNel prossimo passaggio, dobbiamo adattare anche la struttura di controllo del costrutto if. Utilizziamo l’operatore logico AND per collegare la condizione per la richiesta della password con la condizione 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";
}phpIl nostro script “page2.php” ora riceve i valori di username e password e li memorizza nelle variabili $username e $password. L’espressione del costrutto if contiene ora due condizioni collegate dall’operatore logico AND. Solo se entrambe le condizioni sono soddisfatte ($username=="John Doe" e $password=="qwertz123"), if restituisce il risultato TRUE.
Poiché il nome utente viene ottenuto tramite il campo di input username, possiamo utilizzarlo direttamente 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 condizioni non è soddisfatta, viene visualizzato il testo: “Access denied” (Accesso negato).

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 matematiche, anche in PHP è possibile utilizzare le parentesi per influenzare l’ordine.
Condizioni con match
Finora abbiamo gestito le decisioni in PHP con le istruzioni if e else. Tuttavia, quando viene verificato un singolo valore e in base a questo devono risultare esiti diversi, il codice con if può diventare rapidamente poco chiaro. Proprio per questi casi esiste l’istruzione match.
<?php
$status = 404;
echo match ($status) {
200 => "OK",
404 => "Not found",
default => "Unknown status",
};phpIn questo esempio viene verificato il valore della variabile $status. Se corrisponde al valore 200, match restituisce il testo “OK”. Se il valore è 404, viene impostato “Not found” (non trovato). Se nessuno dei valori indicati corrisponde, si applica il caso default e viene usato “Unknown status” (stato sconosciuto).

La differenza più importante rispetto a if-else è che match restituisce direttamente un valore che può essere assegnato a una variabile. In questo modo si evita di scrivere più volte le assegnazioni all’interno delle singole condizioni e il codice rimane più corto, ordinato e di più facile comprensione.
Cicli o loop (while, for)
A volte è necessario che uno script esegua più volte una determinata sezione di codice prima che venga eseguito il resto del codice del programma. Il linguaggio di programmazione PHP utilizza il concetto di ciclo (loop), chiamato anche ciclo PHP. Esistono tre tipi di cicli:
whiledo-whilefor
Ciclo while
Il ciclo while è il tipo più semplice di ciclo disponibile in PHP. La struttura di base corrisponde al seguente schema:
while (condition)
{
loop step and other statements
}phpIl ciclo while indica a PHP di eseguire le istruzioni subordinate fintanto che la condizione while è soddisfatta. Per fare ciò, l’interprete PHP controlla la condizione all’inizio di ogni passaggio del ciclo. L’esecuzione del codice subordinato si interrompe solo quando la condizione while non è più soddisfatta.
Questo principio può essere illustrato con un semplice script numerico:
<?php
$number = 1;
while ($number <= 10) {
echo $number++ . "<br />";
}phpAbbiamo precedentemente introdotto il principio dell’incremento nella sezione “Calcolo con le variabili”. Nello script che segue ci rifacciamo a questo principio, utilizzando però un operatore di post-incremento per aumentare il valore della variabile intera $number di 1 per ogni passaggio del ciclo solo dopo l’output del testo tramite echo. Come condizione per il ciclo while definiamo: $number minore di/uguale a 10. L’istruzione echo viene quindi ripetuta fino a quando $number non ha assunto un valore maggiore di 10.

Il risultato dell’esecuzione dello script è una stringa che riporta il valore della variabile $number per ogni passaggio del ciclo prima che venga incrementato. Pertanto, lo script conta da 1 a 10 e termina l’esecuzione del codice quando la condizione while non è più soddisfatta.
Ciclo do-while
La struttura del ciclo do-while assomiglia a quella del ciclo while. L’unica differenza è che la condizione non viene controllata 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);phpSe programmato come un ciclo do-while, lo script precedente si presenterebbe così:
<?php
$number = 1;
do {
echo $number++ . "<br />";
}
while ($number <= 10);phpIn questo caso, il risultato rimane lo stesso. La peculiarità del ciclo do-while è che viene eseguito almeno una volta, anche se la condizione non viene soddisfatta in nessun passaggio del ciclo.
Ciclo for
In pratica, il ciclo for in uno script PHP ha la stessa funzionalità del ciclo while. Diversamente da quest’ultimo, però, il valore di inizio, la condizione e l’istruzione si trovano all’interno di un’unica riga e non distribuiti su tre o più righe. La struttura di base del ciclo for è la seguente:
for (initial value; condition; loop step)
statementsphpL’esempio già noto potrebbe quindi essere scritto come un ciclo for in forma compatta:
<?php
for($number = 1; $number <= 10; $number++) {
echo $number . "<br /> ";
}phpPrima di tutto, viene definito il valore “1” per la variabile $number. Successivamente, PHP verifica se la condizione $number <= 10 è soddisfatta. Se sì, il ciclo continua e vengono eseguite le istruzioni successive al ciclo (in questo caso l’istruzione echo). Solo a questo punto viene eseguito il passaggio del ciclo; in questo caso, non importa se si sceglie il pre-incremento o il post-incremento, perché il risultato di questa istruzione non viene riutilizzato. Una volta completato il passaggio del ciclo, inizia il passaggio successivo.
Il valore di inizio, la condizione e il passaggio del ciclo sono elementi opzionali di un ciclo for. In linea teorica esistono anche cicli vuoti, ma sarebbero ridondanti.
Generalmente, puoi scegliere se scrivere i tuoi script PHP con un ciclo for o while. C’è però un argomento a favore dei cicli for: assicurano una migliore visione d’insieme dei dati generali del ciclo. Ciò previene il pericolo di scrivere accidentalmente un ciclo infinito che viene eseguito finché la memoria dell’interprete non è piena. Nell’esempio precedente, questo accade quando ci si dimentica di aumentare il valore della variabile $number.
Se però il ciclo deve essere eseguito almeno una volta, indipendentemente dalla condizione, la scelta giusta è il ciclo do-while.
break e continue
L’andamento di un ciclo while, do-while o for può essere influenzato dalle istruzioni break e continue. Si usa break per interrompere il corso di un ciclo in qualsiasi punto e continue per saltare un passaggio del ciclo. Entrambe le istruzioni sono legate a una condizione utilizzando 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 /> ";
}phpNel ciclo for abbiamo definito che il valore della variabile $number, a partire da un valore iniziale di 1, deve essere incrementato del valore 1 a ogni ciclo fino a quando la variabile non avrà raggiunto il valore 10. Interrompiamo questo ciclo prematuramente con l’istruzione break non appena $number ha raggiunto il valore 5. Il costrutto linguistico echo produrrà quindi soltanto i numeri da 1 a 4.

Se vogliamo saltare solo l’output del quinto ciclo senza interrompere l’intero ciclo, sostituiamo l’istruzione break con continue:
<?php
for ($number=1; $number <= 10; $number++) {
if ($number == 5) {
echo "Number 5 is skipped!<br />";
continue;
}
echo $number . "<br /> ";
}phpAl posto della cifra 5, PHP restituisce la stringa di testo definita in if “Number 5 is skipped!” (saltiamo il numero 5!).

Operazioni con i file
I contenuti web dinamici prevedono la separazione tra contenuto e presentazione. I linguaggi di scripting, come PHP, forniscono varie funzionalità che consentono di caricare contenuti da fonti di dati esterne in file di modelli centrali. Sostanzialmente, queste fonti di dati sono database gestiti con sistemi di gestione come MySQL. Inoltre, esiste la possibilità 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 particolarmente 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 corrisponde a una riga del file. Utilizzando file() è quindi più facile produrre ogni riga singolarmente.
Dimostriamo le operazioni con i file PHP sul file di testo “example.txt”, collocato nella cartella “htdocs” del nostro server di prova. Il contenuto del file è costituito da quattro righe di testo 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, assegnarla a una variabile e visualizzarla come testo sul browser web:
<?php
$example = file_get_contents('example.txt');
echo $example;phpNella vista del browser, osserviamo che la stringa di testo viene generata senza paragrafi. Le interruzioni di riga del file originale non sono visibili. Ciò è dovuto al fatto che il browser web interpreta l’output di testo dello script come codice HTML. Le interruzioni di riga definite negli editor di testo vanno quindi perse.

Se desideri attenerti alla struttura originale, hai diverse opzioni. Ad esempio, puoi aggiungere manualmente la codifica HTML per l’interruzione di riga (<br>) nel file sorgente usando il tasto cerca e sostituisci, 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 interruzioni di riga devono essere convertite automaticamente in interruzioni di riga HTML. La funzione va utilizzata secondo il seguente schema:
<?php
$example = file_get_contents('example.txt');
echo nl2br($example);phpSe il costrutto linguistico echo viene usato in combinazione con nl2br(), PHP inserirà un’interruzione di riga HTML prima di ogni nuova riga.

Se desideri emettere le righe di un file singolarmente, 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 assegnazione:
[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 visualizzare il contenuto del file utilizzando echo basta specificare il numero di riga desiderato. 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
Scrivere file
PHP non consente solo di leggere i file, ma offre anche la possibilità di crearli e descriverli per mezzo di contenuti.
A tale scopo utilizziamo la funzione PHP file_put_contents(). Questa funzione necessita di due parametri: il nome del file da creare o aggiornare 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’interruzione di riga nel file di destinazione.
<?php
file_put_contents("test.txt", "This is a test! \r\n");
echo "test.txt has been created!";phpDal momento che file_put_contents non fornisce alcun output per il browser, aggiungiamo un’istruzione echo che ci comunica quale azione viene eseguita.

Se nella cartella di destinazione è già presente un file con lo stesso nome, esso verrà sovrascritto. 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!";phpUtilizzando file_put_contents() con il parametro FILE_APPEND, i nuovi contenuti vengono aggiunti a quelli esistenti.

Il contenuto scritto da PHP nel file di destinazione non deve necessariamente essere definito nello script. Come alternativa, puoi scegliere di trasferire 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- Impostazioni SEO integrate
- Strumento per prenotazioni online
- Dominio e certificato SSL inclusi
Programmazione orientata agli oggetti
La programmazione orientata agli oggetti (OOP) è un metodo per suddividere i programmi in piccoli blocchi gestibili, i cosiddetti oggetti. Ogni oggetto appartiene a una classe che descrive quali proprietà e metodi possiede. Le proprietà sono variabili che memorizzano le caratteristiche dell’oggetto, mentre i metodi sono funzioni che l’oggetto può eseguire. L’OOP aiuta a strutturare meglio il codice, a renderlo riutilizzabile e più facile da manutenere, soprattutto nei progetti di grandi dimensioni.
Classi
Una classe è il modello per un oggetto. Si può immaginare 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();phpIn 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 assegnando la classe “Car” a $myCar. Con -> accediamo alle proprietà dell’oggetto e impostiamo $make su VW e $model su Golf. Successivamente richiamiamo il metodo move(), che restituisce il testo “The car is moving!” (l’auto si sta muovendo). La keyword $this si riferisce all’oggetto corrente all’interno del metodo.

Promozione della proprietà del costruttore
A partire da PHP 8.0 è possibile definire e inizializzare le proprietà direttamente nel costruttore, cioè nel metodo che viene richiamato automaticamente quando si crea un oggetto di una classe. In questo modo non è più necessario dichiararle prima separatamente 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;phpIn questo esempio, le proprietà name e price sono dichiarate direttamente nel costruttore. Quando l’oggetto Product viene creato, i valori “Cup” e “12.99” vengono passati come argomenti. Le espressioni $product->name e $product->price vengono poi usate per accedere ai valori impostati automaticamente. La promozione della proprietà del costruttore riduce la quantità di codice e migliora la leggibilità.
Interfacce
Un’interfaccia definisce quali metodi deve avere una classe senza specificarne l’implementazione concreta. Le classi che implementano l’interfaccia 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();phpIn questo esempio, l’interfaccia Movable specifica che ogni classe che la implementa deve fornire un metodo move(). La classe Car implementa questa interfaccia e definisce il metodo di conseguenza. Viene quindi creato un oggetto della classe e il metodo viene chiamato, restituendo il testo “The car is moving!”.

Tipi di intersezione
I tipi di intersezione sono disponibili da PHP 8.1. Fanno in modo che un oggetto debba soddisfare più interfacce contemporaneamente. Questo è particolarmente utile quando una funzione deve garantire che un oggetto possieda determinate capacità.
interface Loggable {}
function save(JsonSerializable&Loggable $object) {
echo "The object can save JSON data and log information.";
}phpIn questo esempio, gli oggetti passati alla funzione save() devono implementare entrambe le interfacce JsonSerializable e Loggable. La combinazione delle due interfacce è rappresentata da &. Questo garantisce che la funzione lavori solo con oggetti che possiedono entrambe le caratteristiche.
Proprietà di sola lettura
Le proprietà di sola lettura sono disponibili da PHP 8.1. Possono essere impostate una sola volta quando un oggetto viene creato e non possono essere modificate in seguito. Ciò risulta particolarmente utile per proteggere i dati sensibili da modifiche involontarie.
class User {
public function __construct(
public readonly string $name
) {}
}
$user = new User("Max");
echo $user->name;phpIn questo esempio, la proprietà name è definita direttamente nel costruttore e dichiarata come readonly. Di conseguenza, il valore “Max” non può essere modificato 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 impostazioni di configurazione.
Hook delle proprietà
Gli hook delle proprietà sono disponibili dalla versione 8.4 di PHP e ti permettono di eseguire una certa logica direttamente quando imposti o leggi una proprietà. Questo è utile quando i valori devono essere elaborati automaticamente.
class User {
public string $email {
set => strtolower($value);
get => strtoupper($this->email);
}
}
$user = new User();
$user->email = "Test@Example.com";
echo $user->email;phpIn questo esempio, quando un valore viene assegnato alla proprietà email, viene automaticamente convertito in minuscolo, mentre in lettura viene restituito tutto automaticamente in maiuscolo. Questo ti permette di elaborare i dati in modo coerente senza dover scrivere metodi aggiuntivi.
Visibilità asimmetrica
Con la visibilità asimmetrica, introdotta in PHP 8.4, è possibile definire che una proprietà possa essere letta pubblicamente ma modificata solo all’interno della classe stessa. Si proteggono così i dati importanti da modifiche non controllate.
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;phpIn questo esempio, il saldo del conto può essere letto pubblicamente ma può essere modificato solo all’interno della classe. Il metodo deposit() consente di aumentare il saldo in modo controllato. Qualsiasi tentativo di modificare direttamente $balance genera un errore. Questo approccio protegge i dati importanti pur consentendo l’accesso tramite le operazioni consentite.
Scrivere codice PHP pulito
Con l’aumentare delle dimensioni di un progetto cresce anche l’importanza di un codice ben strutturato 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 applicazioni PHP seguono convenzioni specifiche e utilizzano strumenti che favoriscono ordine, chiarezza e sicurezza.
Composer e PSR-4 (caricamento automatico delle classi)
Composer è uno strumento centrale nello sviluppo PHP. Serve a gestire le librerie esterne e a caricare automaticamente le classi PHP. Senza Composer dovresti includere le classi manualmente con require o include, cosa che nei progetti più grandi diventa rapidamente poco chiara. Composer utilizza di norma lo standard di autocaricamento PSR-4. Questo standard definisce come le classi vengono trovate in base al loro nome e alla loro posizione di salvataggio. Il nome di una classe corrisponde alla struttura di cartelle in cui è memorizzata.
Un semplice esempio illustra questo principio. Se una classe User appartiene allo spazio dei nomi App\Model, il file corrispondente si trova nella cartella src/Model:
<?php
namespace App\Model;
class User {
public function getName() {
return "Max Mustermann";
}
}phpGrazie a PSR-4, questa classe può essere utilizzata in qualsiasi punto del progetto senza includere manualmente il file. PHP la carica automaticamente non appena è necessaria. Questo rende il codice più organizzato e riduce le possibili fonti di errore.
Uso dei namespace per una struttura del codice più chiara
Gli spazi dei nomi (namespace) aiutano a raggruppare logicamente le classi ed evitare conflitti di denominazione. Nei piccoli script non è un problema chiamare semplicemente le classi User o Database. Nelle applicazioni più grandi, però, più classi possono condividere lo stesso nome pur avendo scopi diversi. I namespace ti permettono di distinguere chiaramente queste classi. Per esempio, può esserci una classe User per il database e un’altra classe User per la visualizzazione nel front end senza creare conflitti.
L’esempio seguente mostra come viene utilizzato uno spazio dei nomi:
<?php
namespace App\Service;
class Mailer {
public function send() {
echo "Email has been sent.";
}
}phpQuando usi la classe, viene utilizzato il nome completo comprensivo dello spazio dei nomi oppure viene importato tramite use. In questo modo il codice rimane non ambiguo e ben strutturato.
Struttura del progetto: file .env e .gitignore
Una struttura di progetto chiara è un elemento importante di un codice PHP pulito. I progetti PHP separano il vero e proprio codice del programma dai file pubblicamente accessibili e dai dati di configurazione. Spesso il codice PHP si trova in una cartella dedicata, mentre il server web può accedere solo a una directory pubblica.
I valori di configurazione come le credenziali di accesso al database o le chiavi API di solito non vengono salvati direttamente nel codice. Al loro posto si utilizzano i cosiddetti file .env, in cui questi valori vengono memorizzati in modo centralizzato. Questo aumenta la sicurezza e facilita il passaggio tra ambiente di sviluppo e di produzione.
Un esempio semplice di file .env potrebbe essere il seguente:
DB_HOST=localhost
DB_USER=root
DB_PASSWORD=secrettextQuesto file viene consapevolmente non salvato nel sistema di controllo della versione. A questo provvede il file .gitignore, che stabilisce quali file o cartelle devono essere ignorati da Git. Nel file .gitignore il file .env viene escluso esplicitamente, in modo che i dati sensibili non vengano pubblicati per errore.
Gestione degli errori e file di log
La gestione degli errori differisce tra l’ambiente di sviluppo e quello di produzione. Durante lo sviluppo è utile visualizzare direttamente i messaggi di errore PHP, in modo da riconoscere e risolvere rapidamente i problemi.
Nelle applicazioni di produzione, invece, i messaggi di errore non dovrebbero essere visibili, perché potrebbero rivelare informazioni interne. Al loro posto, gli errori vengono scritti in file di log, accessibili solo alle sviluppatrici e agli sviluppatori.
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);phpIn un ambiente di produzione viene disattivata la visualizzazione degli errori e attivati i log. PHP scrive quindi gli errori che si verificano in un file di log, senza mostrarli alle persone che visitano il sito web. In questo modo l’applicazione rimane stabile e sicura, pur mantenendo una documentazione tracciabile degli errori.
Nozioni di base di database con PHP: un semplice esempio PDO
Per salvare o leggere dati con PHP, è necessario un database. In questo esempio utilizziamo MySQL, che è incluso per impostazione predefinita in XAMPP. PHP può comunicare in modo sicuro con il database tramite PDO, ovvero PHP Data Objects. PDO garantisce che i comandi vengano eseguiti correttamente e offre i prepared statement: i segnaposto 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 phpMyAdmin 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’identificazione 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
);sqlOperazioni nei database in PHP
Ora creiamo un file “crud.php” nella cartella “htdocs” di XAMPP. In questo esempio stabiliamo una connessione al database e mostriamo innanzitutto le operazioni 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'
]);
?>phpPer prima cosa viene stabilita una connessione al database con PDO. A questo scopo indichiamo host, nome del database, nome utente, password e set di caratteri. PDO garantisce che i comandi SQL vengano eseguiti in modo sicuro e che gli errori risultino visibili.
Successivamente mostriamo le quattro operazioni fondamentali:
CREATE(inserimento di dati): conINSERT INTOinseriamo un nuovo utente. I segnaposto:usernamee:emailgarantiscono che gli input degli utenti vengano elaborati in modo sicuro.READ(dati in lettura): conSELECT * FROM usersrecuperiamo tutti i record esistenti. ConfetchAll()salviamo i risultati in un array e li mostriamo in un elenco chiaro e ordinato.UPDATE(modificare dati): conUPDATEpossiamo cambiare l’indirizzo e-mail di un utente. Usiamo di nuovo dei segnaposto per inserire i valori in modo sicuro.DELETE(eliminare dati): conDELETE FROM users WHERE username = :usernameeliminiamo un determinato utente dal database. Il segnaposto:usernamegarantisce che l’input venga elaborato in modo sicuro, senza che un hacker possa manipolare il database. In questo modo possiamo cancellare singoli record specifici senza influenzare l’intera tabella.
Input dell’utente e trattamento 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 manipolare i campi di un modulo, inviare dati imprevisti oppure tentare deliberatamente di abusare di un’applicazione. Per questo motivo PHP mette a disposizione diverse funzioni con cui è possibile verificare, elaborare e salvare in modo sicuro i dati inseriti.
Archiviare i dati in modo sicuro nei database: prepared statement
Una delle falle di sicurezza più comuni nelle applicazioni PHP si verifica quando si lavora con i database. Se gli input degli utenti vengono inseriti direttamente nelle query SQL, può verificarsi una cosiddetta SQL injection. In questo modo chi attacca inietta un proprio codice SQL.
Le dichiarazioni preparate (prepared statement) evitano questo problema separando in modo rigoroso il codice SQL dai dati degli utenti. PHP mette a disposizione a questo scopo l’interfaccia di accesso al database PDO.
<?php
$stmt = $pdo->prepare("SELECT * FROM users WHERE username = :username");
$stmt->execute([
'username' => $username
]);phpIl codice prepara una query al database per cercare tutti gli utenti nella tabella users il cui nome utente corrisponde a un determinato valore. Invece di inserire il nome utente direttamente nel comando SQL, viene usato il segnaposto :username, che viene riempito con un valore concreto solo al momento dell’esecuzione della query. In questo modo PHP separa il codice SQL dai dati degli utenti e impedisce che gli input possano manipolare il comando.
Proteggere l’output: escaping
Non solo la memorizzazione dei dati, ma anche la loro visualizzazione può essere pericolosa. Se le immissioni degli utenti vengono mostrate nel browser senza alcun filtro, può verificarsi il cosiddetto cross-site scripting (XSS). In questo caso, nel browser di altri utenti viene eseguito codice dannoso. Per evitarlo, l’output viene mascherato. In PHP ciò avviene di solito con la funzione htmlspecialchars() e il testo viene mostrato, ma non interpretato come codice.
<?php
echo htmlspecialchars("<h1>Hello World!</h1>", ENT_QUOTES, 'UTF-8');php
Filtrare gli input utente: filter_input()
PHP offre con filter_input() la possibilità di verificare e ripulire i dati inseriti dall’utente già in fase di lettura. In questo modo è possibile riconoscere tempestivamente valori non validi o indesiderati. Un esempio semplice è la lettura di un indirizzo e-mail:
<?php
$email = filter_input(INPUT_POST, 'email', FILTER_VALIDATE_EMAIL);phpSe l’input non è un indirizzo e-mail valido, la funzione restituisce 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 continuare a elaborare i dati.
Salvare le password in modo sicuro con password_hash()
Le password non devono mai essere memorizzate in chiaro. Anche una semplice cifratura non è sufficiente. PHP mette a disposizione la funzione password_hash(), che esegue l’hashing sicuro delle password.
<?php
$hash = password_hash($password, PASSWORD_DEFAULT);phpAl login successivo, la password inserita viene verificata con password_verify():
<?php
if (password_verify($password, $hash)) {
echo "Login successful";
}phpIl valore effettivo della password non è mai più visibile. Anche in caso di violazione del database, le password restano protette.
Protezione dalla manipolazione dei moduli: token CSRF
Nei moduli esiste il rischio che vengano inviati all’insaputa delle persone che li usano. Per evitarlo, si utilizzano i cosiddetti 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));phpQuesta riga genera un codice di sicurezza casuale, difficile da indovinare, e lo salva nella sessione corrente dell’utente. La funzione random_bytes(32) crea 32 byte casuali, cioè dati grezzi non direttamente leggibili. Con bin2hex() questi dati grezzi vengono trasformati in una stringa ben leggibile composta da lettere e numeri. Il valore generato viene salvato in $_SESSION['token'] e usato in seguito per verificare se un modulo proviene davvero dalla stessa sessione.
Caricamento di file con convalida
Anche i caricamenti di file sono particolarmente sensibili e possono comportare rischi per la sicurezza, poiché in questo modo file esterni arrivano sul server. Per questo motivo è sempre necessario controllare il tipo di file e la dimensione del file.
Un esempio semplice per il controllo delle dimensioni di un file potrebbe essere il seguente:
<?php
if ($_FILES['upload']['size'] > 1000000) {
echo "File is too big.";
}phpIl codice verifica quanto è grande il file caricato e lo confronta con un valore massimo prefissato di 1.000.000 byte. Se il file è più grande del consentito, viene visualizzato un messaggio di errore e il caricamento può essere rifiutato. In questo modo si impedisce che file troppo grandi vengano caricati sul server. Inoltre, si dovrebbe verificare che si tratti davvero del tipo di file atteso, ad esempio un’immagine. I file non dovrebbero mai essere memorizzati sul server in modo eseguibile senza essere controllati.

