Imparare a programmare in PHP: tutorial per principianti
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.
Tutorial PHP: una guida completa
Il nostro tutorial si rivolge principalmente a chi è neofita. 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
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
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();
?>
Gli 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: phpinfo( INFO_ALL ). Ogni istruzione termina con un punto e virgola (;). Per chiudere l’ambiente di script, si usa il tag PHP di chiusura: ?>.
Le funzioni sono sottoprogrammi che consentono di esternalizzare parti del codice del programma. Per evitare la ridondanza, i compiti ricorrenti possono essere definiti come una funzione e poi richiamati usando il relativo nome. Chi lavora nello sviluppo web utilizza le funzioni PHP predefinite o crea i propri sottoprogrammi.
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.
Se l’installazione è andata a buon fine, ora dovresti poter vedere la seguente pagina web come risultato dell’esecuzione dello script:
La funzione phpinfo() è la forma breve del valore standard phpinfo( INFO_ALL ). Essa fornisce informazioni dettagliate sulla configurazione PHP del server web. Qualora non sia possibile trovare alcuna versione di PHP, il browser web visualizzerà un messaggio di errore oppure il codice PHP verrà consegnato al browser senza che questo sia in grado di 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!';
?>Il tag di apertura <?php apre un ambiente di script. Seguono il costrutto linguistico echo e la stringa Hello World! racchiusa in virgolette singole. Per terminare lo script, è necessario il tag ?>. Attenzione al punto e virgola dopo l’istruzione. Al posto di Hello World! puoi scrivere qualsiasi testo.
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>';
?>Quando 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 un titolo di primo ordine. È 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.
L’utente PHP incontrerà variabili nella forma seguente, ad esempio: &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 sette 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, il punto decimale è scritto come un punto (.). PHP supporta fino a 14 cifre decimali. |
| 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 principianti, 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. |
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";Il 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 (&example1 o $_example), mai con una cifra (errato: $example).
- 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>";
?>Il 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.
È qui che la forza di PHP diventa evidente: i contenuti possono essere incorporati come variabili. È questa la caratteristica alla base dello sviluppo web dinamico. Diversamente dalle pagine web statiche, già disponibili come pagine HTML pronte all’uso, le pagine web dinamiche vengono create soltanto nel momento in cui la pagina viene consultata. L’interprete PHP carica i singoli elementi della pagina web richiesta da vari database con l’aiuto delle variabili e li assembla in una pagina HTML personalizzata secondo la richiesta.
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>";
?>
Nell’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;
?>Questo è vero a meno che la variabile non debba essere utilizzata all’interno di una stringa. In tal caso, infatti, va usata una doppia virgoletta (“), che segnala 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>';
?>
Forse ti starai chiedendo cosa succede se ometti del tutto le virgolette. In questo caso, PHP segnala un errore sintattico.
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!;
?>*Nella 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.
Nell’esempio presente, è stato rilevato un errore nella riga 2 del codice del programma, proprio dove abbiamo omesso le virgolette a scopo dimostrativo.
Gli errori sintattici si verificano anche quando vogliamo produrre come testo dei caratteri che sono associati a un’attività specifica in PHP. Un esempio è l’apostrofo (’). Caratteri di questo tipo possono essere visualizzati come testo in PHP solo a condizione che si chiarisca all’interprete che il carattere è stato esonerato dal suo compito effettivo. Nel caso dell’apostrofo, hai a disposizione due opzioni: racchiudere una stringa con apostrofo in doppie virgolette o mascherare le virgolette mediante barre rovesciate (\):
<?php
echo '\'Hello World!\' ';
?>
È possibile anche la combinazione di virgolette singole e doppie:
<?php
echo " 'Hello World!' ";
?>Tuttavia, non è ammessa la seguente scrittura:
<?php
echo ' 'Hello World!' ';
?>Gli 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>";
?>È 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>';
?>
Si 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;
?>Per estendere il valore di una variabile, definiscila di nuovo, ma metti l’operatore di concatenazione punto (.) davanti al simbolo di uguale. Si tratta in questo caso dellascrittura abbreviata usuale 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:
<?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="it">
<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>Aggiungiamo ora uno script PHP al documento HTML. Assicurati che l’intero codice del programma sia all’interno dei tag PHP.
<!DOCTYPE html>
<html lang="it">
<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>Nell’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 = giorno.mese.anno ora:minuto:secondo
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 vuoi 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!
?>L’editor di testo Notepad++ evidenzia i commenti in verde. A differenza dei commenti HTML, i passaggi di testo contrassegnati come commenti nell’ambiente di script non arrivano nemmeno sul browser web, perché vengono già ignorati dall’interprete PHP durante l’esecuzione dello script.
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>';
?>Anche 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 integer o 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;
?>Per 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 variabili $number1 e $number2. Per farlo, ci serviamo dell’operatore aritmetico +(più). Infine, il risultato dell’addizione viene visualizzato come testo utilizzando il costrutto linguisticoecho. 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
?><?php
echo "Result addition: " . $addition ."<br />";
echo "Result subtraction: " . $subtraction . "<br />";
echo "Result multiplication: " . $multiplication . "<br />";
echo "Result division: " . $division . "<br />";
echo "10 to the 5th power: " . $exponentiation . "<br />";
echo "Square root of 81: " . sqrt(81) . "<br />";
?>
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;
?>L’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 calcola 2*(2,5+5“)*(3,7-3)*√81 e restituisce il risultato 94,5.
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;
?>Aumentando 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;
?>In 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>';
?>In 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.
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 forename (nome) e surname (cognome) da una stringa di ricerca HTTP e scriverli nelle variabili PHP $variable1 e $variable2:
<?php
$variable1 = $_GET['forename'];
$variable2 = $_GET['surname'];
echo "Hello " . $variable1 . " " . $variable2 . "!";
?>L’esecuzione dello script avviene tramite il seguente URL:
localhost/hello.php?forename=John&surname=Doe
In questo modo trasmettiamo i parametri forename=Johnesurname=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 HTTP POST. I dati trasferiti con questo metodo si trovano nella superglobale $_POST.
Trasmissione dei dati tramite $_POST
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 />
Forename: <input type="text" name="forename" /><br />
Surname: <input type="text" name="surname" /><br />
Email address: <input type="text" name="email" /><br />
<input type="submit" value="Submit form" />
</form>Per creare i moduli viene utilizzato l’elemento HTML <form>. Ciò comprende due attributi nel tag iniziale: methodeaction. 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
$forename = $_POST["forename"];
$surname = $_POST["surname"];
$email = $_POST["email"];
echo "Hello" . $forename . " " . $surname . ", <br />
you are registered with the following email address: " . $email . ".";
?>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 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 $forename = $_POST[“forename”] aprono l’input nel campo forename e lo salvano nella variabile $forename. La variabile $forename 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, impareremo 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;
}
?>Il 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 ifrestituisce il risultatoTRUE (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;
}La 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” //TRUE 1 === “1” //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 fulfilled";
}Definiamo le variabili $number1 e $number2 e assegniamo loro i valori 10e20. 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 ifrestituisce il risultatoTRUE. “The condition is fulfilled” (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)
{
instruction b;
}
else
{
instruction c
}
?>Questo script controlla anche se la condizione a restituisce il risultato TRUE o FALSE. Se la condizione a è soddisfatta (TRUE), viene eseguita l’istruzione b. Se lacondizione anon è soddisfatta (FALSE), l’istruzione bviene 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 fulfilled";
}
else
{
echo " The condition is not fulfilled";
}
?>Questa volta il costrutto ifrestituisce il risultatoFALSE. Il valore della variabile $number1 non è uguale al valore della variabile $number2. “The condition is not fulfilled” (La condizione non è soddisfatta). Pertanto, viene eseguita soltanto l’istruzione definita sotto if e non 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.
<?php
$number1 = 10;
$number2 = 20;
if ($number1 == $number2)
{
echo "The numbers are the same.";
}
if (!($number1 == $number2))
{
echo "The numbers are different.";
}
?>L’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.phpepage2.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>La 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";
}
?>Il 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 ifrestituisce il risultatoFALSE, 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.
Ti invitiamo a verificare 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 ANDeOR.
| 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 OR e || vincolano più strettamente di AND e OR. Inoltre, AND e && sono più vincolanti di OR e ||. Questo è paragonabile all’ordine di precedenza degli operatori matematici (ad esempio, ** è più vincolante di +).
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>Nel 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 internal area" . $username . "!";
}
else
{
echo "Access denied";
}
?>Il 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”),ifrestituisce il risultatoTRUE.
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 internal 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.
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:
- while
- do-while
- for
Ciclo PHP 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 instructions
}Il 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 />";
}
?>Abbiamo 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 maggiore 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 PHP do-while
La struttura del ciclo PHP do-while assomiglia a quella del ciclo PHP 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 instructions
}
while (condition)Se programmato come un ciclo do-while, lo script precedente avrebbe il seguente aspetto:
<?php
$number = 1;
do {
echo $number++ . "<br />";
}
while ($number <= 10);
?>In 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 PHP 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 (initail value; condition; loop step)
instructionsL’esempio già noto potrebbe quindi essere scritto come un ciclo for in forma compatta:
<?php
for($number = 1; $number <= 10; $number++) {
echo $number . "<br /> ";
}
?>Prima di tutto, viene definito il valore 1 per la variabile $number. Successivamente, PHP verifica se la condizione $number <= 1 è 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é questa istruzione viene comunque eseguita prima che avvenga l’output. Una volta completato il loop step, inizia il passaggio successivo.
Valore iniziale, condizione e 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 PHP do-while.
break e continue
L’andamento di un ciclo while, do-while o for può essere influenzato dalle istruzioni breakecontinue. 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 "The script stops at 5";
break;
}
echo $number . "<br /> ";
}
?>Nel 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 "We skip number 5!<br />";
continue;
}
echo $number . "<br /> ";
}
?>Al posto della cifra 5, PHP restituisce la stringa di testo definita in if We skip number 5! (Escludiamo il numero 5!).
Operazioni con i file
I contenuti web dinamici prevedono la separazione tra contenuto e presentazione. I linguaggi di script, 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. Per sapere come funziona, consultate il nostro tutorial su 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()efile_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:
Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem.
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;
?>
Nella 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 vuoi 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 (new lines) devono essere convertite automaticamente in interruzioni di riga HTML (breaks). La funzione va utilizzata secondo il seguente schema:
<?php
$example = file_get_contents('example.txt');
echo nl2br($example);
?>Se 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 esempio.txt come output sul browser:
<?php
$example = file("example.txt");
echo $example [0];
?>
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 was created!";
?>
Dal 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 was updated!";
?>Utilizzando 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 esempio.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 was updated!";
?>
