PHP: 3 Guida Completa alla Sintassi PHP: Dalle Basi alle Funzioni Avanzate
Riccardo Brivio
28 Apr, 2025
Cos’è PHP e Come Iniziare: Le Basi Essenziali
In questo articolo trattiamo il linguaggio PHP in generale, le sue istruzioni e la sintassi. Come abbiamo già visto nell’introduzione generale, PHP è un linguaggio interpretato, quindi il codice non viene tradotto (all’interno di un nuovo file) in linguaggio macchina prima dell’esecuzione. Un programma chiamato interprete (Zend Engine) lo legge riga per riga a runtime e lo trasforma in linguaggio macchina immediatamente. Di conseguenza, per scrivere un programma basta inserire il codice PHP in un file con estensione .php e farlo eseguire dall’interprete. PHP è un linguaggio lato server, quindi il codice viene eseguito sul Server Web e successivamente la risposta viene inviata al client (come abbiamo già visto).
Delimitare il Codice PHP: I Tag Fondamentali
Tutti i programmi PHP iniziano con il tag di apertura <?php e terminano con il tag di chiusura ?>. Nel caso in cui il termine del file coincida con la fine del programma, il tag ?> può anche essere omesso.
Il Tuo Primo Script PHP: L’Indispensabile “Hello World”
Vediamo ora il classico programma che stampa a video la scritta “Hello World” (molto simile a quello della lezione precedente in cui stampavamo la scritta “Prova”). Eliminiamo il file index.php (se presente), apriamo VS Code e scriviamo queste poche righe di codice:
<?php
// Stampo a video la scritta Hello World
echo "Hello World";
?>Visualizziamo l’output del programma salvandolo all’interno della Document Root del WebServer (htdocs/ per XAMPP, www/ per MAMP, etc.) chiamiamolo primo_script.php. Aprendo l’indirizzo corrispondente nel browser (in questo caso http://localhost/primo_script.php o http://127.0.0.1/primo_script.php), vedremo stampato all’interno della viewport la stringa “Hello World”, come sequenza di caratteri attraverso l’istruzione echo.
Il Potere dell’Integrazione: Mescolare PHP e HTML
Vediamo ora come PHP permette di “mischiare” codice HTML e PHP all’interno di un file .php, ricreiamo lo stesso esempio, aggiungendo una struttura HTML. Eliminiamo il codice inserito in precedenza e scriviamo il seguente:
<!DOCTYPE html>
<html lang="it">
<head>
<meta charset="UTF-8">
<title>Esempio PHP e HTML</title>
</head>
<body>
<h1><?php echo "Hello World"; ?></h1>
</body>
</html>Questo esempio è molto intuitivo perché ci permette di capire il potenziale straordinario di PHP: è possibile scrivere una pagina HTML e variare il contenuto di un titolo, una tabella o qualsiasi altro elemento HTML (attingendo anche da database) in modo dinamico, ad esempio in base a una data, al contenuto di una variabile o all’utente che visualizza il sito. Come si vede dall’esempio, il codice PHP è sempre delimitato dai tag <?php ?>.
Commentare il Codice PHP: La Chiave per la Leggibilità Futura
Vediamo ora come si inseriscono i commenti all’interno dei tag PHP:
<?php
/*
Questo è un esempio
di commento che si estende
su più righe.
*/
// Questo è un commento su una riga singola
# Anche questo è un commento su una riga singola (stile shell)
?>È fondamentale commentare il codice. Leggere un codice scritto a distanza di tempo può essere complicato senza commenti adeguati. Tuttavia, è bene tenere presente che esagerare con i commenti può risultare controproducente e appesantire la lettura.
Fatti questi semplici esempi per poterci ambientare durante la scrittura di codice PHP e capito come si commenta il codice, vediamo ora la sintassi delle istruzioni, le variabili e i tipi di dati.
Variabili e Tipi di Dati Fondamentali in PHP
In programmazione, il tipo di dato specifica la natura del valore che una variabile può assumere o le tipologie di dati che il linguaggio sa gestire. PHP è in grado di gestire i seguenti tipi di dati primitivi e composti:
- boolean: Valori vero (
true) o falso (false). - integer: Numeri interi (es. -10, 0, 123).
- double (o float): Numeri in virgola mobile (es. 3.14, -0.5).
- string: Sequenze di caratteri (testo).
- array: Collezioni ordinate di dati.
- object: Istanze di classi.
- resource: Riferimenti a risorse esterne (es. connessioni a database, file aperti).
- NULL: Un tipo speciale che rappresenta l’assenza di valore.
Se volete ulteriori dettagli esclusivi e informazioni sui tipi di dati disponibili in PHP, vi consiglio di consultare la documentazione ufficiale.
Memorizzare Dati: Le Variabili PHP
I dati vengono memorizzati in variabili. Una variabile non è altro che una locazione di memoria identificata da un nome, utilizzata per memorizzare temporaneamente dati o informazioni.
- Dichiarazione: Le variabili in PHP vengono dichiarate (e spesso inizializzate contestualmente) utilizzando il prefisso dollaro (
$). - Nomenclatura: Tutti i nomi di variabili devono cominciare con una lettera o un underscore (
_), seguiti da lettere, numeri o underscore. - Case Sensitivity: È cruciale ricordare che i nomi di variabili sono case sensitive, ossia
$aè diversa da$A. - Tipizzazione Dinamica: Un altro aspetto fondamentale da tenere sempre a mente è che le variabili PHP non sono tipizzate staticamente. Di conseguenza, è possibile assegnare alla stessa variabile tipi di dati differenti durante l’esecuzione dello script:
<?php
$prova = "ciao"; // $prova ora è una stringa
echo gettype($prova) . "\n"; // Output: string
$prova = 3; // $prova ora è un intero
echo gettype($prova) . "\n"; // Output: integer
?>Certamente! Analizziamo il tuo articolo e vediamo come ottimizzarlo per la SEO con Rank Math, aggiungendo titoli e power words.
Analisi del Contenuto:
L’articolo copre in modo molto completo le basi fondamentali della sintassi PHP:
- Tag PHP e integrazione con HTML.
- Commenti.
- Variabili e tipi di dati (con focus su stringhe, numeri, array).
- Costanti.
- Operatori (aritmetici, di confronto, logici).
- Strutture di controllo (condizionali
if/else/switch, cicliwhile/do-while/for/foreach). - Funzioni (definizione, parametri, return, opzionali, variadic, anonime, type hinting).
Suggerimento Parola Chiave Principale (Focus Keyword per Rank Math):
Considerando il contenuto dettagliato sulla struttura del linguaggio, una parola chiave efficace potrebbe essere:
Sintassi PHP
- Perché: È centrale rispetto all’argomento trattato (tag, variabili, operatori, strutture di controllo, funzioni sono tutti elementi della sintassi). È un termine che chi inizia a imparare PHP o cerca un ripasso probabilmente cercherà.
- Alternative valide (come secondarie): “Fondamenti PHP”, “Guida PHP base”, “Variabili PHP”, “Funzioni PHP”, “Cicli PHP”.
Revisione dell’Articolo con Titoli SEO e Power Words:
Ecco il tuo articolo riscritto con l’aggiunta di titoli H2/H3 ottimizzati per la SEO (che includono la parola chiave o termini correlati dove naturale) e alcune “power words” per aumentare l’engagement.
Titolo Originale: PHP: 3 Il linguaggio la Sintassi e le Istruzioni (Suggerimento Titolo SEO): Guida Completa alla Sintassi PHP: Dalle Basi alle Funzioni Avanzate
(Introduzione – mantenuta ma inserita sotto un H2)
Cos’è PHP e Come Iniziare: Le Basi Essenziali
In questo articolo trattiamo il linguaggio PHP in generale, le sue istruzioni e la sintassi. Come abbiamo già visto nell’introduzione generale, PHP è un linguaggio interpretato, quindi il codice non viene tradotto (all’interno di un nuovo file) in linguaggio macchina prima dell’esecuzione. Un programma chiamato interprete (Zend Engine) lo legge riga per riga a runtime e lo trasforma in linguaggio macchina immediatamente. Di conseguenza, per scrivere un programma basta inserire il codice PHP in un file con estensione .php e farlo eseguire dall’interprete. PHP è un linguaggio lato server, quindi il codice viene eseguito sul Server Web e successivamente la risposta viene inviata al client (come abbiamo già visto).
Delimitare il Codice PHP: I Tag Fondamentali
Tutti i programmi PHP iniziano con il tag di apertura <?php e terminano con il tag di chiusura ?>. Nel caso in cui il termine del file coincida con la fine del programma, il tag ?> può anche essere omesso.
Il Tuo Primo Script PHP: L’Indispensabile “Hello World”
Vediamo ora il classico programma che stampa a video la scritta “Hello World” (molto simile a quello della lezione precedente in cui stampavamo la scritta “Prova”). Eliminiamo il file index.php (se presente), apriamo VS Code e scriviamo queste poche righe di codice:
PHP
<?php
// Stampo a video la scritta Hello World
echo "Hello World";
?>
Visualizziamo l’output del programma salvandolo all’interno della Document Root del WebServer (htdocs/ per XAMPP, www/ per MAMP, etc.) chiamiamolo primo_script.php. Aprendo l’indirizzo corrispondente nel browser (in questo caso http://localhost/primo_script.php o http://127.0.0.1/primo_script.php), vedremo stampato all’interno della viewport la stringa “Hello World”, come sequenza di caratteri attraverso l’istruzione echo.
Il Potere dell’Integrazione: Mescolare PHP e HTML
Vediamo ora come PHP permette di “mischiare” codice HTML e PHP all’interno di un file .php, ricreiamo lo stesso esempio, aggiungendo una struttura HTML. Eliminiamo il codice inserito in precedenza e scriviamo il seguente:
PHP
<!DOCTYPE html>
<html lang="it">
<head>
<meta charset="UTF-8">
<title>Esempio PHP e HTML</title>
</head>
<body>
<h1><?php echo "Hello World"; ?></h1>
</body>
</html>
Questo esempio è molto intuitivo perché ci permette di capire il potenziale straordinario di PHP: è possibile scrivere una pagina HTML e variare il contenuto di un titolo, una tabella o qualsiasi altro elemento HTML (attingendo anche da database) in modo dinamico, ad esempio in base a una data, al contenuto di una variabile o all’utente che visualizza il sito. Come si vede dall’esempio, il codice PHP è sempre delimitato dai tag <?php ?>.
Commentare il Codice PHP: La Chiave per la Leggibilità Futura
Vediamo ora come si inseriscono i commenti all’interno dei tag PHP:
PHP
<?php
/*
Questo è un esempio
di commento che si estende
su più righe.
*/
// Questo è un commento su una riga singola
# Anche questo è un commento su una riga singola (stile shell)
?>
È fondamentale commentare il codice. Leggere un codice scritto a distanza di tempo può essere complicato senza commenti adeguati. Tuttavia, è bene tenere presente che esagerare con i commenti può risultare controproducente e appesantire la lettura.
Fatti questi semplici esempi per poterci ambientare durante la scrittura di codice PHP e capito come si commenta il codice, vediamo ora la sintassi delle istruzioni, le variabili e i tipi di dati.
Variabili e Tipi di Dati Fondamentali in PHP
In programmazione, il tipo di dato specifica la natura del valore che una variabile può assumere o le tipologie di dati che il linguaggio sa gestire. PHP è in grado di gestire i seguenti tipi di dati primitivi e composti:
- boolean: Valori vero (
true) o falso (false). - integer: Numeri interi (es. -10, 0, 123).
- double (o float): Numeri in virgola mobile (es. 3.14, -0.5).
- string: Sequenze di caratteri (testo).
- array: Collezioni ordinate di dati.
- object: Istanze di classi.
- resource: Riferimenti a risorse esterne (es. connessioni a database, file aperti).
- NULL: Un tipo speciale che rappresenta l’assenza di valore.
Se volete ulteriori dettagli esclusivi e informazioni sui tipi di dati disponibili in PHP, vi consiglio di consultare la documentazione ufficiale.
Memorizzare Dati: Le Variabili PHP
I dati vengono memorizzati in variabili. Una variabile non è altro che una locazione di memoria identificata da un nome, utilizzata per memorizzare temporaneamente dati o informazioni.
- Dichiarazione: Le variabili in PHP vengono dichiarate (e spesso inizializzate contestualmente) utilizzando il prefisso dollaro (
$). - Nomenclatura: Tutti i nomi di variabili devono cominciare con una lettera o un underscore (
_), seguiti da lettere, numeri o underscore. - Case Sensitivity: È cruciale ricordare che i nomi di variabili sono case sensitive, ossia
$aè diversa da$A. - Tipizzazione Dinamica: Un altro aspetto fondamentale da tenere sempre a mente è che le variabili PHP non sono tipizzate staticamente. Di conseguenza, è possibile assegnare alla stessa variabile tipi di dati differenti durante l’esecuzione dello script:
PHP
<?php
$prova = "ciao"; // $prova ora è una stringa
echo gettype($prova) . "\n"; // Output: string
$prova = 3; // $prova ora è un intero
echo gettype($prova) . "\n"; // Output: integer
?>
Le istruzioni sopra sono assolutamente valide. Pur non essendo un linguaggio tipizzato staticamente, PHP mette a disposizione la funzione gettype() che ci permette di conoscere il tipo di una variabile in un dato momento (utile per il debug).
Definire Costanti PHP: Valori Fissi e Indispensabili
PHP consente anche di creare costanti, ossia delle “variabili” particolari il cui valore non può cambiare una volta definito. Vengono utilizzate per memorizzare informazioni che non devono variare durante l’esecuzione del programma (es. configurazioni, valori fissi). Vediamo un esempio autoesplicativo:
<?php
// Definisco una costante (convenzione: nome in maiuscolo)
define('MESSAGGIO_BENVENUTO', 'Ciao e benvenuto!');
// Stampo a video la costante (senza il $!)
echo MESSAGGIO_BENVENUTO; // Output: Ciao e benvenuto!
// Altro modo per stampare (utile se il nome è in una variabile)
echo constant('MESSAGGIO_BENVENUTO');
?>Padroneggiare i Tipi di Dati Essenziali: Stringhe, Numeri e Array
Vediamo ora nel dettaglio tre dei tipi di dati più utilizzati e potenti in PHP: le stringhe, i numeri (integer e double) e gli array.
Manipolare Testo: Le Stringhe in PHP
Le stringhe non sono altro che una sequenza di caratteri (ASCII o UTF-8, a seconda della configurazione) racchiusi tra apici singoli (') o doppi (").
- Apici Singoli (
'): Il contenuto viene trattato letteralmente. Le variabili e le sequenze di escape (come\nper andare a capo) non vengono interpretate.
<?php
$mondo = 'mondo';
echo 'Ciao $mondo \n'; // Output: Ciao $mondo \n
?>- Apici Doppi (
"): Il contenuto viene interpretato. Le variabili vengono sostituite con il loro valore e le sequenze di escape vengono processate.
<?php
$nome = 'Mario';
echo "Benvenuto, $nome!\n"; // Output: Benvenuto, Mario! (e va a capo)
?>- Concatenazione: Le stringhe possono essere unite (concatenate) utilizzando l’operatore punto (
.).
<?php
$nome = 'Mario';
$cognome = 'Rossi';
// Concatenazione con apici doppi (interpretazione variabili)
$nome_completo_interpretato = "$nome $cognome";
echo $nome_completo_interpretato . "\n"; // Output: Mario Rossi
// Concatenazione esplicita con operatore .
$nome_completo_concatenato = $nome . ' ' . $cognome;
echo $nome_completo_concatenato . "\n"; // Output: Mario Rossi
?>PHP offre una vasta gamma di funzioni “predefinite” molto comode che ci permettono di manipolare le stringhe. Eccone alcune indispensabili:
strlen($stringa): Fornisce la lunghezza (numero di byte/caratteri) di una stringa.strtoupper($stringa): Trasforma una stringa in maiuscolo.strtolower($stringa): Trasforma una stringa in minuscolo.substr($stringa, $inizio, $lunghezza): Permette di estrarre una sotto-stringa.strpos($stringa, $sottostringa_da_cercare): Trova la posizione (indice) della prima occorrenza di una sotto-stringa all’interno di un’altra. Restituiscefalsese non trovata.str_replace($cerca, $sostituisci, $stringa): Sostituisce tutte le occorrenze di una sotto-stringa con un’altra.
Facciamo come di consueto un esempio per capire meglio:
<?php
// Definiamo una stringa
$stringa = "Ciao mondo!";
// Calcolo la lunghezza della stringa
echo "Lunghezza: " . strlen($stringa) . "\n"; // Output: Lunghezza: 11 (o 12 se si conta lo spazio invisibile?) -> *Nota: strlen conta i byte, può variare con UTF-8. `mb_strlen` è meglio per multbyte.*
// Converte la stringa in lettere maiuscole
echo "Maiuscolo: " . strtoupper($stringa) . "\n"; // Output: Maiuscolo: CIAO MONDO!
// Converte la stringa in lettere minuscole
echo "Minuscolo: " . strtolower($stringa) . "\n"; // Output: Minuscolo: ciao mondo!
// Estrae una sottostringa ("Ciao")
echo "Sottostringa: " . substr($stringa, 0, 4) . "\n"; // Output: Sottostringa: Ciao
// Trova la posizione di "mondo" (indice base 0)
$posizione = strpos($stringa, "mondo");
if ($posizione !== false) {
echo "Posizione 'mondo': " . $posizione . "\n"; // Output: Posizione 'mondo': 5
} else {
echo "'mondo' non trovato.\n";
}
// Sostituisce "mondo" con "WebProbe.it"
echo "Sostituzione: " . str_replace("mondo", "WebProbe.it", $stringa) . "\n"; // Output: Sostituzione: Ciao WebProbe.it!
?>Per maggiori informazioni strategiche riguardo alle funzioni per le stringhe, è utile consultare la documentazione ufficiale.
Nota sull’esempio substr: L’esempio originale menzionava che le stringhe sono una “tipologia speciale” di array. Sebbene si possa accedere ai singoli caratteri usando la sintassi degli array (es. $stringa[0]), è più corretto dire che molte funzioni per stringhe operano su indici o posizioni, simile a come si fa con gli array.
Lavorare con i Numeri in PHP: Operazioni Matematiche Fondamentali
PHP gestisce due tipi principali di numeri:
- integer (
int): Numeri interi, positivi, negativi o zero, senza parte decimale. - double (
float): Numeri in virgola mobile (numeri reali). Importante: Il separatore decimale in PHP (e in molti linguaggi) è il punto (.), non la virgola. Es:1.2345.
Vediamo alcune delle principali operazioni matematiche in PHP tramite un semplice esempio:
<?php
// Addizione
$somma = 5 + 3; // $somma vale 8
// Sottrazione
$differenza = 10 - 4; // $differenza vale 6
// Moltiplicazione
$prodotto = 6 * 7; // $prodotto vale 42
// Divisione
$quoziente = 20 / 5; // $quoziente vale 4 (integer, perché la divisione è esatta)
$quoziente_float = 10 / 3; // $quoziente_float vale 3.333... (float)
// Modulo (resto della divisione intera)
$resto = 11 % 3; // $resto vale 2 (perché 11 = 3*3 + 2)
// Potenza (Attenzione: l'operatore ^ è XOR bitwise, usare pow() o **)
$potenza = pow(2, 3); // $potenza vale 8 (2 elevato alla 3)
$potenza_operatore = 2 ** 3; // $potenza_operatore vale 8 (sintassi più recente)
echo "Somma: $somma, Differenza: $differenza, Prodotto: $prodotto, Quoziente: $quoziente, Resto: $resto, Potenza: $potenza\n";
?>È inoltre possibile incrementare o decrementare facilmente le variabili numeriche:
<?php
$numero = 5;
// Operatore Post-Incremento: usa il valore attuale, POI incrementa
echo "Post-incremento: " . $numero++ . "\n"; // Output: Post-incremento: 5
echo "Valore dopo post-incremento: " . $numero . "\n"; // Output: Valore dopo post-incremento: 6
// Operatore Pre-Incremento: PRIMA incrementa, POI usa il nuovo valore
$numero = 10;
echo "Pre-incremento: " . ++$numero . "\n"; // Output: Pre-incremento: 11
echo "Valore dopo pre-incremento: " . $numero . "\n"; // Output: Valore dopo pre-incremento: 11
// N.B. Lo stesso vale per il decremento (--$var e $var--)
$a = 5; echo --$a; // Output: 4
$b = 5; echo $b--; // Output: 5 (poi $b diventa 4)
?>Come per le stringhe, anche per i numeri, PHP mette a disposizione svariate funzioni matematiche utilissime:
sqrt($numero): Calcola la radice quadrata.abs($numero): Ritorna il valore assoluto (sempre positivo).round($numero, $precisione = 0): Arrotonda un float all’intero più vicino o a un numero specificato di cifre decimali.floor($numero): Arrotonda per difetto all’intero inferiore.ceil($numero): Arrotonda per eccesso all’intero superiore.max($val1, $val2, ...)omax($array): Restituisce il valore massimo.min($val1, $val2, ...)omin($array): Restituisce il valore minimo.rand($min, $max)omt_rand($min, $max): Genera un numero intero casuale (mt_randè generalmente preferito).
<?php
// Radice quadrata
$radice = sqrt(16); // $radice = 4
// Valore assoluto
$valoreAssoluto = abs(-15); // $valoreAssoluto = 15
// Arrotondamento
$numeroArrotondato = round(3.14159); // $numeroArrotondato = 3
$numeroArrotondatoPreciso = round(3.14159, 2); // $numeroArrotondatoPreciso = 3.14
// Arrotondamento inferiore
$arrotondamento_inferiore = floor(7.9); // $arrotondamento_inferiore = 7
// Arrotondamento superiore
$arrotondamento_superiore = ceil(7.1); // $arrotondamento_superiore = 8
// Valore massimo
$massimo = max(10, 50, 20, 5); // $massimo = 50
// Valore minimo da un array
$valori = [10, 50, 20, 5];
$minimo = min($valori); // $minimo = 5
echo "Radice: $radice, Assoluto: $valoreAssoluto, Round: $numeroArrotondato, Floor: $arrotondamento_inferiore, Ceil: $arrotondamento_superiore, Max: $massimo, Min: $minimo\n";
?>Gli Array in PHP: Collezioni di Dati Potenti e Flessibili
Un array in PHP è una struttura dati fondamentale che rappresenta una collezione ordinata (mappe ordinate, per essere precisi) di valori. Può contenere qualsiasi tipo di dato, inclusi numeri, stringhe, booleani, altri array e oggetti, rendendoli incredibilmente versatili.
Creare Array Indicizzati
Negli array indicizzati (o numerici), ogni valore è associato a un indice numerico intero, che parte da 0 per impostazione predefinita.
<?php
// Creazione tramite il costrutto array() (vecchia sintassi)
$vecchio_array = array(10, 20, 30, "ciao", true);
// Creazione tramite parentesi quadre [] (sintassi moderna e preferita)
$array_indicizzato = [10, 20, 30, "ciao", true];
// Accesso agli elementi tramite indice (base 0)
echo $array_indicizzato[0]; // Output: 10
echo $array_indicizzato[3]; // Output: ciao
// Modifica di un elemento
$array_indicizzato[1] = 25; // Ora il secondo elemento è 25
print_r($array_indicizzato); // print_r è utile per visualizzare il contenuto di un array
/* Output:
Array
(
[0] => 10
[1] => 25
[2] => 30
[3] => ciao
[4] => 1
)
*/
?>Aggiungere Elementi agli Array Indicizzati
Per aggiungere elementi in coda a un array esistente, puoi usare la funzione array_push() o, più comunemente e leggermente più performante per un singolo elemento, la sintassi con parentesi quadre vuote []:
<?php
$mesi = ["Gennaio", "Febbraio"];
// Aggiungo più elementi con array_push()
array_push($mesi, "Marzo", "Aprile");
// Aggiungo un singolo elemento con []
$mesi[] = "Maggio";
// var_dump() fornisce informazioni più dettagliate di print_r (tipo e valore)
var_dump($mesi);
/* Output:
array(5) {
[0]=>
string(7) "Gennaio"
[1]=>
string(8) "Febbraio"
[2]=>
string(5) "Marzo"
[3]=>
string(6) "Aprile"
[4]=>
string(6) "Maggio"
}
*/
?>var_dump() è uno strumento di debug inestimabilmente utile per ispezionare il contenuto e il tipo delle variabili, specialmente array e oggetti.
Creare Array Associativi
Un array associativo è un tipo di array estremamente potente in cui si utilizzano chiavi (tipicamente stringhe, ma anche interi) personalizzate invece di indici numerici sequenziali per accedere ai valori. Sono perfetti per rappresentare dati strutturati come le proprietà di un oggetto.
<?php
// Creazione di un array associativo
$utente = [
"nome" => "Mario",
"cognome" => "Rossi",
"eta" => 30, // Nota: 'eta' è la chiave, 30 è il valore
"citta" => "Roma"
];
// Accesso ai valori tramite chiave
echo "Nome: " . $utente["nome"] . "\n"; // Output: Nome: Mario
echo "Età: " . $utente["eta"] . "\n"; // Output: Età: 30
// Aggiunta di un nuovo elemento chiave-valore
$utente["email"] = "mario.rossi@example.com";
// Modifica di un valore esistente
$utente["eta"] = 31;
var_dump($utente);
/* Output:
array(5) {
["nome"]=>
string(5) "Mario"
["cognome"]=>
string(5) "Rossi"
["eta"]=>
int(31)
["citta"]=>
string(4) "Roma"
["email"]=>
string(23) "mario.rossi@example.com"
}
*/
?>Funzioni Essenziali per Manipolare gli Array
PHP offre un arsenale di funzioni per lavorare con gli array. Ecco alcune delle più importanti:
count($array): Ritorna il numero di elementi presenti in un array.sort($array): Ordina un array indicizzato in ordine crescente (modifica l’array originale).rsort($array): Ordina un array indicizzato in ordine decrescente (modifica l’array originale).asort($array): Ordina un array associativo in base ai valori, mantenendo le chiavi (modifica l’array originale).ksort($array): Ordina un array associativo in base alle chiavi (modifica l’array originale).in_array($valore, $array): Verifica se un valore è presente in un array (restituiscetrueofalse).array_key_exists($chiave, $array): Verifica se una chiave esiste in un array associativo.array_push($array, $val1, ...): Aggiunge uno o più elementi alla fine di un array.array_pop($array): Rimuove e restituisce l’ultimo elemento da un array.array_shift($array): Rimuove e restituisce il primo elemento da un array.array_unshift($array, $val1, ...): Aggiunge uno o più elementi all’inizio di un array.array_merge($array1, $array2, ...): Unisce due o più array.array_keys($array): Restituisce un array contenente tutte le chiavi.array_values($array): Restituisce un array contenente tutti i valori.
Vediamo un esempio pratico:
<?php
$frutta = ["mela", "banana", "arancia"];
// Conteggio elementi
echo "Numero frutti: " . count($frutta) . "\n"; // Output: Numero frutti: 3
// Aggiunta
array_push($frutta, "kiwi"); // ["mela", "banana", "arancia", "kiwi"]
$frutta[] = "mango"; // ["mela", "banana", "arancia", "kiwi", "mango"]
// Rimozione primo elemento
$primo = array_shift($frutta); // $primo = "mela", $frutta = ["banana", "arancia", "kiwi", "mango"]
echo "Rimosso il primo: $primo\n";
// Rimozione ultimo elemento
$ultimo = array_pop($frutta); // $ultimo = "mango", $frutta = ["banana", "arancia", "kiwi"]
echo "Rimosso l'ultimo: $ultimo\n";
// Verifica presenza
if (in_array("banana", $frutta)) {
echo "La banana è presente!\n"; // Output: La banana è presente!
}
// Ordinamento
sort($frutta); // Ora $frutta è ["arancia", "banana", "kiwi"]
print_r($frutta);
?>Logica Condizionale in PHP: Prendere Decisioni Cruciali con if, else e switch
Scrivendo codice, capita molto spesso di dover eseguire una porzione di codice solo se si verifica una determinata condizione. È qui che entrano in gioco le istruzioni condizionali, che permettono al tuo script di prendere decisioni.
Il Blocco if, else if, else
In PHP, le condizioni sono definite principalmente attraverso l’uso delle parole chiave if, elseif (o else if) ed else, come in molti altri linguaggi di programmazione.
<?php
$temperatura = 15;
if ($temperatura < 0) {
echo "Fa molto freddo!\n";
} elseif ($temperatura < 10) {
echo "Fa freddo.\n";
} elseif ($temperatura < 20) {
echo "La temperatura è mite.\n"; // Questa condizione è vera
} elseif ($temperatura < 30) {
echo "Fa caldo.\n";
} else {
echo "Fa molto caldo!\n";
}
// Output: La temperatura è mite.
?>L’esecuzione procede dall’if iniziale. Appena una condizione (if o elseif) risulta vera, il blocco di codice corrispondente viene eseguito e l’intera struttura condizionale termina. Se nessuna delle condizioni if o elseif è vera, viene eseguito il blocco else (se presente).
Operatori di Confronto e Logici: Il Cuore delle Condizioni
Le condizioni si basano sugli operatori di confronto per paragonare valori e sugli operatori logici per combinare più condizioni.
Operatori di Confronto Principali:
| Operatore | Descrizione | Esempio ($a=5, $b='5') | Risultato |
|---|---|---|---|
== | Uguale a (solo valore) | $a == $b | true |
=== | Identico a (valore E tipo) | $a === $b | false |
!= | Diverso da (solo valore) | $a != $b | false |
<> | Diverso da (alternativo a !=) | $a <> $b | false |
!== | Non identico (valore O tipo) | $a !== $b | true |
< | Minore di | $a < 10 | true |
> | Maggiore di | $a > 10 | false |
<= | Minore o uguale a | $a <= 5 | true |
>= | Maggiore o uguale a | $a >= 5 | true |
<=> | Spaceship (PHP 7+): -1 se < , 0 se ==, 1 se > | $a <=> 10 | -1 |
Operatori Logici Principali:
| Operatore | Nome | Descrizione |
|---|---|---|
&& | AND | Restituisce true se entrambe le condizioni sono vere. |
and | AND | Come &&, ma con precedenza inferiore (usare &&). |
| ` | ` | OR |
or | OR | Come ` |
! | NOT | Nega la condizione (restituisce true se è false, e viceversa). |
xor | XOR | Restituisce true se esattamente una delle condizioni è vera. |
<?php
$eta = 25;
$ha_patente = true;
// AND: entrambe devono essere vere
if ($eta >= 18 && $ha_patente) {
echo "Può guidare.\n"; // Output: Può guidare.
}
// OR: almeno una deve essere vera
$permesso_speciale = false;
if ($ha_patente || $permesso_speciale) {
echo "Ha un documento valido per guidare.\n"; // Output: Ha un documento valido per guidare.
}
// NOT: nega la condizione
if (!$permesso_speciale) {
echo "Non ha il permesso speciale.\n"; // Output: Non ha il permesso speciale.
}
?>Per maggiori dettagli strategici sull’argomento, consiglio di guardare la documentazione ufficiale sugli operatori.
L’Operatore Ternario: Una Scorciatoia Elegante per l’if-else
Esiste anche una forma contratta dell’if-else, nota come operatore ternario, molto utile per assegnare un valore a una variabile in base a una condizione semplice. La sintassi è:
(condizione) ? (valore_se_vero) : (valore_se_falso)
Il punto interrogativo ? funge da then, mentre i due punti : sono l’else. Se la condizione risulta verificata, viene restituito il valore_se_vero, altrimenti il valore_se_falso.
Vediamo un semplice esempio chiarificatore:
<?php
$eta_utente = 15;
$status = ($eta_utente >= 18) ? "Maggiorenne" : "Minorenne";
echo "Stato: " . $status . "\n"; // Output: Stato: Minorenne
// Molto usato con le variabili _GET/_POST/_SESSION per fornire valori di default
$nome_utente = isset($_GET['nome']) ? $_GET['nome'] : 'Ospite';
echo "Benvenuto, $nome_utente!\n"; // Se ?nome=Mario nell'URL, stampa "Benvenuto, Mario!", altrimenti "Benvenuto, Ospite!"
// Operatore Null Coalescing (PHP 7+) - ancora più corto per isset()
$cognome_utente = $_GET['cognome'] ?? 'Sconosciuto'; // Se $_GET['cognome'] esiste ed è non-null, usa quello, altrimenti 'Sconosciuto'
echo "Cognome: $cognome_utente\n";
?>Lo Statement switch: Gestire Casi Multipli con Chiarezza
L’istruzione switch offre un’alternativa all’if-elseif-else quando devi confrontare il valore di una singola variabile (o espressione) con una serie di valori specifici (casi).
<?php
$giorno_settimana = "Martedì";
switch ($giorno_settimana) {
case "Lunedì":
echo "Inizio settimana lavorativa.\n";
break; // IMPORTANTE: Esce dallo switch
case "Martedì":
case "Mercoledì":
case "Giovedì":
echo "Giorno lavorativo.\n";
break; // Esce dopo Martedì, Mercoledì o Giovedì
case "Venerdì":
echo "Quasi weekend!\n";
break;
case "Sabato":
case "Domenica":
echo "Weekend!\n";
break;
default:
echo "Valore non riconosciuto come giorno della settimana.\n";
// Nessun break necessario qui
}
// Output: Giorno lavorativo.
?>Punti chiave dello switch:
- Confronta il valore dell’espressione nello
switchcon il valore di ognicase. - Quando trova una corrispondenza, esegue il codice da quel
casein poi. - L’istruzione
breakè essenziale per uscire dalloswitchdopo che un caso è stato eseguito. Se dimentichibreak, l’esecuzione “cade” (fall through) al caso successivo, cosa raramente desiderata. - Il
defaultè opzionale e viene eseguito se nessuncasecorrisponde.
Cicli Iterativi in PHP: Automatizzare Compiti Ripetitivi con while, for e foreach
I cicli sono strutture di controllo indispensabili che permettono di eseguire ripetutamente un blocco di codice finché una determinata condizione rimane vera (o per un numero specifico di volte). PHP mette a disposizione 3 tipi principali di cicli iterativi:
Ciclo while: Ripetizione Basata su Condizione (Controllo in Testa)
Il ciclo while esegue il blocco di codice finché la condizione specificata all’inizio risulta true. La condizione viene controllata prima di ogni iterazione.
<?php
$contatore = 0; // 1. Inizializzazione
while ($contatore < 5) { // 2. Condizione (controllata prima di ogni giro)
echo "Iterazione numero: " . $contatore . "\n";
$contatore++; // 3. Aggiornamento (fondamentale per evitare cicli infiniti!)
}
// Output:
// Iterazione numero: 0
// Iterazione numero: 1
// Iterazione numero: 2
// Iterazione numero: 3
// Iterazione numero: 4
echo "Fine ciclo while. Contatore vale: " . $contatore . "\n"; // Output: Fine ciclo while. Contatore vale: 5
?>Se la condizione è falsa fin dall’inizio, il corpo del ciclo while non verrà eseguito nemmeno una volta.
Ciclo do-while: Ripetizione Garantita Almeno Una Volta (Controllo in Coda)
Il ciclo do-while è simile al while, ma con una differenza cruciale: la condizione viene controllata alla fine di ogni iterazione. Questo garantisce che il blocco di codice venga eseguito almeno una volta, anche se la condizione è inizialmente falsa.
<?php
$tentativi = 0;
do {
echo "Eseguo il blocco... Tentativo: " . $tentativi . "\n";
// Qui potresti inserire codice che DEVE essere eseguito almeno una volta
$tentativi++;
} while ($tentativi < 0); // Condizione falsa fin dall'inizio
// Output:
// Eseguo il blocco... Tentativo: 0
echo "Fine ciclo do-while. Tentativi: " . $tentativi . "\n"; // Output: Fine ciclo do-while. Tentativi: 1
?>Ciclo for: Controllo Completo sull’Iterazione Numerica
Il ciclo for è una delle istruzioni più utilizzate, specialmente quando si conosce in anticipo (o si può calcolare) il numero di iterazioni necessarie. La sua sintassi compatta include tre parti, separate da punto e virgola, all’interno delle parentesi:
for (inizializzazione; condizione; espressione_finale) { // Istruzioni da eseguire }
- Inizializzazione: Eseguita una sola volta all’inizio del ciclo (es.
$i = 0;). - Condizione: Valutata all’inizio di ogni iterazione. Se
true, il corpo del ciclo viene eseguito. Sefalse, il ciclo termina. (es.$i < 10;). - Espressione Finale: Eseguita alla fine di ogni iterazione, dopo l’esecuzione del corpo del ciclo (es.
$i++;).
Vediamo l’esempio del while riscritto con un for:
<?php
for ($i = 0; $i < 5; $i++) {
echo "Iterazione FOR numero: " . $i . "\n";
}
// Output: (Identico all'esempio while)
// Iterazione FOR numero: 0
// ...
// Iterazione FOR numero: 4
// echo $i; // ERRORE! O meglio, $i potrebbe esistere o meno a seconda delle versioni PHP e contesti.
// Meglio considerare $i come interna al ciclo for in questo caso.
?>Nota sull’esempio originale: La nota sulla variabile $i che viene distrutta non è universalmente vera per i cicli for in PHP (a differenza di altri linguaggi o contesti specifici come le funzioni). La variabile $i definita nell’inizializzazione del for generalmente rimane accessibile dopo il ciclo con il valore che ha causato l’uscita dalla condizione (nell’esempio sopra, $i varrebbe 5 dopo il ciclo). Tuttavia, fare affidamento su questo comportamento può essere meno chiaro che usare un while se serve il valore finale.
Ciclo foreach: Il Modo Ideale ed Elegante per Scorrere gli Array
PHP offre una versione specializzata e molto comoda del ciclo for, chiamata foreach, progettata specificamente per iterare sugli elementi degli array (o oggetti iterabili). È il modo preferito e più leggibile per lavorare con collezioni di dati.
L’istruzione foreach ha due varianti di sintassi:
- Iterare solo sui Valori:
foreach ($array as $variabile_valore) {
// Codice da eseguire per ogni elemento.
// Ad ogni iterazione, $variabile_valore conterrà il valore
// dell'elemento corrente dell'array.
}2. Iterare su Chiavi e Valori (per array associativi o se serve l’indice):
foreach ($array as $variabile_chiave => $variabile_valore) {
// Codice da eseguire per ogni elemento.
// Ad ogni iterazione:
// $variabile_chiave conterrà la chiave/indice corrente.
// $variabile_valore conterrà il valore corrente.
}Vediamo entrambe le sintassi in azione:
<?php
// Esempio con array indicizzato (solo valori)
$colori = ["rosso", "verde", "blu"];
echo "Colori (solo valori):\n";
foreach ($colori as $colore) {
echo "- " . strtoupper($colore) . "\n";
}
// Output:
// Colori (solo valori):
// - ROSSO
// - VERDE
// - BLU
// Esempio con array associativo (chiavi e valori)
$capitali = [
"Italia" => "Roma",
"Francia" => "Parigi",
"Germania" => "Berlino"
];
echo "\nCapitali (chiavi e valori):\n";
foreach ($capitali as $nazione => $capitale) {
echo "La capitale di $nazione è $capitale.\n";
}
// Output:
// Capitali (chiavi e valori):
// La capitale di Italia è Roma.
// La capitale di Francia è Parigi.
// La capitale di Germania è Berlino.
?>break e continue: Modificare il Flusso Standard dei Cicli
All’interno dei cicli (while, do-while, for, foreach), puoi usare due istruzioni speciali per alterarne il normale flusso:
break;: Interrompe immediatamente l’esecuzione del ciclo corrente. Il programma continua con la prima istruzione dopo il ciclo.continue;: Salta il resto dell’iterazione corrente e passa immediatamente all’inizio dell’iterazione successiva (rivalutando la condizione nelwhile/for, o prendendo l’elemento successivo nelforeach).
<?php
$numeri = [1, 2, -3, 4, 5, -6, 7];
echo "Esempio con break e continue:\n";
foreach ($numeri as $num) {
if ($num < 0) {
echo "Trovato numero negativo ($num), interrompo il ciclo.\n";
break; // Esce completamente dal foreach
}
if ($num % 2 == 0) {
echo "Numero pari ($num), salto all'iterazione successiva.\n";
continue; // Salta l'echo "Numero dispari" qui sotto
}
echo "Numero dispari: $num\n";
}
// Output:
// Esempio con break e continue:
// Numero dispari: 1
// Numero pari (2), salto all'iterazione successiva.
// Trovato numero negativo (-3), interrompo il ciclo.
?>Sono istruzioni potenti ma usale con cautela, in quanto possono rendere il flusso del codice meno intuitivo se abusate. Per maggiori informazioni strategiche sui cicli, si rimanda alla documentazione ufficiale.
Funzioni in PHP: Organizzare e Riutilizzare il Codice in Modo Efficace
Le funzioni sono blocchi di codice riutilizzabili che eseguono un compito specifico. Permettono di organizzare il codice in unità logiche, riducono la duplicazione e rendono i programmi più leggibili e manutenibili. Sono un concetto fondamentale della programmazione strutturata e orientata agli oggetti.
Abbiamo già visto e usato molte funzioni native di PHP (es. echo, gettype(), strlen(), count(), etc.). PHP permette anche di creare facilmente le tue funzioni personalizzate.
Definire e Chiamare Funzioni Personalizzate
La sintassi base per definire una funzione è:
function nome_funzione($parametro1, $parametro2, ...) {
// Corpo della funzione: istruzioni da eseguire
// ...
return $valore_restituito; // Opzionale: restituisce un valore
}function: Parola chiave che introduce la definizione di una funzione.nome_funzione: Nome univoco che userai per chiamare la funzione (segue le stesse regole di nomenclatura delle variabili, ma è case-insensitive per convenzione storica, anche se è buona norma usare sempre lo stesso case).($parametro1, ...): Elenco opzionale di parametri (variabili) che la funzione accetta in input.{ ... }: Corpo della funzione contenente il codice da eseguire.return $valore;: Istruzione opzionale per restituire un valore al punto in cui la funzione è stata chiamata. Sereturnviene omesso o usato senza valore, la funzione restituisceNULL.
Vediamo un esempio di codice in cui dichiariamo una funzione che prende in ingresso un array di numeri e ne calcola la somma:
<?php
// Definizione della funzione
function somma_array($array_numeri) {
$somma = 0;
foreach ($array_numeri as $numero) {
// Controlliamo se l'elemento è effettivamente un numero
if (is_numeric($numero)) {
$somma += $numero; // $somma = $somma + $numero;
}
}
return $somma; // Restituisce il risultato del calcolo
}
// Chiamata della funzione
$miei_numeri = [10, 20, 30, 40, 50];
$risultato_somma = somma_array($miei_numeri); // Chiama la funzione e memorizza il valore restituito
echo "La somma dell'array è: " . $risultato_somma; // Output: La somma dell'array è: 150
?>Parametri Opzionali e Valori di Default: Massima Flessibilità
Alle funzioni PHP è possibile passare parametri con valori di default, rendendoli opzionali quando si chiama la funzione. Per rendere opzionale un parametro, è necessario assegnargli un valore predefinito nella definizione della funzione.
Importante: I parametri opzionali devono essere sempre dichiarati dopo tutti i parametri obbligatori nell’elenco dei parametri.
<?php
function saluta($nome, $saluto = "Ciao") {
echo "$saluto, $nome!\n";
}
// Chiamate valide:
saluta("Anna"); // Output: Ciao, Anna! (usa il default "Ciao")
saluta("Marco", "Buongiorno"); // Output: Buongiorno, Marco! (sovrascrive il default)
// Esempio dall'articolo originale con type hint
function esempio_opzionale(int $valore_obbligatorio, array $opzioni = []) {
echo "Valore: $valore_obbligatorio, Opzioni: " . count($opzioni) . "\n";
}
esempio_opzionale(10); // Output: Valore: 10, Opzioni: 0
esempio_opzionale(20, [1, 2, 3]); // Output: Valore: 20, Opzioni: 3
?>Parametri Variadic: Accettare un Numero Indefinito di Argomenti
Oltre ai parametri opzionali, PHP (dalla versione 5.6) permette di specificare che una funzione può accettare un numero indefinito di argomenti finali tramite l’operatore variadic (...). Questi argomenti vengono raccolti in un array all’interno della funzione.
Facciamo un esempio autoesplicativo:
<?php
// Funzione che somma un numero indefinito di argomenti
function somma_numeri(...$numeri) {
// $numeri ora è un array contenente tutti gli argomenti passati
$somma = 0;
foreach ($numeri as $numero) {
if (is_numeric($numero)) {
$somma += $numero;
}
}
return $somma;
}
// Chiamata della funzione con 3 argomenti
echo "Somma (1, 2, 3): " . somma_numeri(1, 2, 3) . "\n"; // Output: Somma (1, 2, 3): 6
// Chiamata della funzione con 5 argomenti
echo "Somma (10, 20, 30, 40, 50): " . somma_numeri(10, 20, 30, 40, 50) . "\n"; // Output: Somma (10, 20, 30, 40, 50): 150
// Chiamata senza argomenti aggiuntivi
echo "Somma (): " . somma_numeri() . "\n"; // Output: Somma (): 0
?>Funzioni Anonime (Closure): Flessibilità al Massimo Livello
In PHP, le funzioni anonime (note anche come Closure) sono funzioni senza un nome definito. Possono essere assegnate a variabili e passate come argomenti ad altre funzioni (rendendole perfette per callback o strategie semplici).
Sono particolarmente utili quando si ha bisogno di definire una funzione “al volo” per un uso specifico e limitato, senza doverla dichiarare formalmente.
<?php
// Creazione di una funzione anonima assegnata a una variabile
$moltiplica = function($a, $b) {
return $a * $b;
}; // Nota il punto e virgola obbligatorio qui!
// Utilizzo della funzione anonima tramite la variabile
echo "Moltiplicazione: " . $moltiplica(5, 4) . "\n"; // Output: Moltiplicazione: 20
// Esempio: uso come callback per array_map (applica la funzione a ogni elemento)
$numeri = [1, 2, 3, 4];
$quadrati = array_map(function($n) {
return $n * $n;
}, $numeri);
print_r($quadrati); // Output: Array ( [0] => 1 [1] => 4 [2] => 9 [3] => 16 )
?>Le funzioni anonime possono anche “ereditare” variabili dall’ambito esterno usando la parola chiave use:
<?php
$fattore = 10;
$moltiplica_per_fattore = function($valore) use ($fattore) {
return $valore * $fattore;
};
echo $moltiplica_per_fattore(5); // Output: 50
?>Type Hinting (Dichiarazione dei Tipi): Aumentare la Robustezza del Codice
Con l’avvento di PHP 7 e versioni successive, è stata introdotta e potenziata la possibilità di dichiarare i tipi per i parametri delle funzioni e per i valori di ritorno. Questo aiuta a scrivere codice più robusto, prevedibile e auto-documentante, riducendo errori a runtime.
- Tipo Parametri: Si specifica il tipo atteso prima del nome del parametro.
- Tipo Valore di Ritorno: Si specifica dopo i due punti (
:) dopo la parentesi chiusa dei parametri.
<?php
// Funzione con tipi dichiarati per parametri e ritorno
function calcola_area_rettangolo(float $larghezza, float $altezza): float {
// Se vengono passati tipi non compatibili (es. stringhe non numeriche),
// PHP genererà un TypeError (a meno che strict_types non sia attivo).
return $larghezza * $altezza;
}
$area = calcola_area_rettangolo(5.5, 10.0);
echo "Area: " . $area . "\n"; // Output: Area: 55
// PHP tenta la coercizione di tipo di default (es. un int può diventare float)
$area_int = calcola_area_rettangolo(5, 10);
echo "Area (int): " . $area_int . "\n"; // Output: Area (int): 50
// Esempio con tipo 'string' e 'int'
function ripeti_stringa(string $testo, int $volte): string {
if ($volte < 0) return ""; // Gestione caso limite
return str_repeat($testo, $volte);
}
echo ripeti_stringa("Php", 3); // Output: PhpPhpPhp
?>È importante notare che, per impostazione predefinita, PHP tenta di coercire i tipi (es. passare l’intero 5 a un parametro che richiede float funziona). Per abilitare una modalità più stringente che genera errori se i tipi non corrispondono esattamente, puoi usare declare(strict_types=1); all’inizio del file PHP.
Tipi Nullable: Gestire l’Assenza di Valore con Eleganza
PHP 7.1 ha introdotto i tipi nullable, che permettono a un parametro o a un valore di ritorno di essere del tipo specificato OPPURE null. Si indicano anteponendo un punto interrogativo (?) prima del tipo.
Questo è estremamente utile per indicare che un valore potrebbe legittimamente mancare.
<?php
declare(strict_types=1); // Abilitiamo la modalità stringente per chiarezza
function trova_utente_db(int $id): ?array { // Può restituire un array o null
// Simulazione ricerca database
if ($id === 1) {
return ["id" => 1, "nome" => "Alice"];
} elseif ($id === 2) {
return ["id" => 2, "nome" => "Bob"];
} else {
return null; // Utente non trovato
}
}
function stampa_nome_utente(?array $utente) { // Accetta un array o null
if ($utente !== null) {
echo "Nome utente: " . $utente['nome'] . "\n";
} else {
echo "Utente non trovato.\n";
}
}
$utente1 = trova_utente_db(1);
stampa_nome_utente($utente1); // Output: Nome utente: Alice
$utente3 = trova_utente_db(3);
stampa_nome_utente($utente3); // Output: Utente non trovato.
// Esempio dall'articolo originale
function stampaStringa(?string $stringa): void // 'void' indica che la funzione non restituisce nulla
{
if ($stringa !== null) {
echo $stringa . "\n";
} else {
echo "La stringa è null.\n";
}
}
stampaStringa("Ciao Mondo!"); // Output: Ciao Mondo!
stampaStringa(null); // Output: La stringa è null.
?>Nota Importante sugli Array Type Hint: Come correttamente indicato nell’articolo originale, quando si usa array come type hint, non è possibile (nativamente in PHP fino alle versioni attuali, PHP 8.x) specificare il tipo degli elementi contenuti nell’array (es. non puoi dire array<int> per indicare un array di soli interi). Per questo si usano spesso le DocBlock (commenti speciali come @param int[] $numeri) o librerie esterne per l’analisi statica, oppure si valida il contenuto all’interno della funzione.
Conclusione e Prossimi Passi
In questa guida approfondita, abbiamo esplorato la sintassi fondamentale di PHP, coprendo tutto, dai tag di base e le variabili, fino alle potenti strutture di controllo e alla definizione di funzioni flessibili. Comprendere questi elementi è cruciale per costruire qualsiasi applicazione PHP, dalle più semplici alle più complesse.
Nel prossimo articolo, ci addentreremo in concetti più avanzati come la Programmazione Orientata agli Oggetti (OOP) in PHP o la gestione dei form e dei dati inviati dall’utente. Continua a seguirci su WebProbe.it!
In questo articolo trattiamo il linguaggio php in generale, le sue istruzioni e la sintassi. Come abbiamo già visto nell’introduzione generale php è un linguaggio interpretato, quindi il codice non viene tradotto (all’interno di un nuovo file) in linguaggio macchina prima dell’esecuzione. Un programma chiamato interprete (Zend Engine) lo legge riga per riga a runtime e lo trasforma in linguaggio macchina immediatamente. Di conseguenza per scrivere un programma basta inserire il codice php in un file con estensione .php e farlo eseguire dall’interprete. PHP è un linguaggio lato server quindi il codice viene eseguito sul Server Web e successivamente la risposta viene inviata al client (come abbiamo già visto). Tutti i programmi PHP iniziano con il tag di apertura <?php e terminano con il tag di chiusura ?>, nel caso in cui il termine del file coincide con la fine del programma il tag ?> può anche essere omesso. Vediamo ora il classico programma che stampa a video la scritta “Hello World” (molto simile a quello della lezione precedente in cui stampavamo la scritta “Prova”). Eliminiamo il file index.php apriamo VS Code e scriviamo queste poche righe di codice:
<?php
// Stampo a video la scritta Hello World
echo "Hello World";
?>Visualizziamo l’output del programma salvandolo all’interno della Document Root del WebServer (htdocs/) chiamiamolo primo_script.php. Aprendo l’indirizzo corrispondente (in questo caso http://www.localhost/primo_script.php), vedremo stampato all’interno della viewport del browser la stringa Hello Word, come sequenza di caratteri attraverso la funzione echo.
Vediamo ora come php permette di “mischiare” codice html e php all’interno di un file “.php”, ricreiamo lo stesso esempio, aggiungendo una struttura html, eliminiamo il codice inserito in precedenza e scriviamo il seguente:
<!DOCTYPE html>
<html lang="it_IT">
<head>
<title>Esempio</title>
</head>
<body>
<h1><?php echo "Hello World"; ?></h1>
</body>
</html>Questo esempio è molto intuitivo perché ci permette di capire il potenziale di php, infatti, è possibile scrivere una pagina html e variare il contenuto di un titolo, una tabella o qualsiasi altro elemento html (attingendo anche dal database) in modo dinamico, ad esempio in base ad una data, al contenuto di una variabile o all’utente che visualizza il sito. Come si vede dal esempio il codice php è sempre delimitato dai tag <?php ?>.
Vediamo ora come si inseriscono i commenti all’interno dei tag php:
<?php
/*
Esempio di commento
su più righe
*/
// Commento su una riga
# Altro metodo per commentare su una rigaÉ buona norma commentare il codice, leggere un codice scritto a distanza di tempo può essere complicato senza commenti, è bene tenere presente che esagerare con icommenti può risultare controproducente.
Fatti questi semplici esempi per poter ambientarci durante la scrittura di codice php e capito come si commenta il codice, vediamo ora la sintassi delle istruzioni le variabili e i tipi di dati.
Tipi di dati e variabili
In programmazione il tipo di dato specifica il valore che una variabile può assumere o le tipologie di dati che il linguaggio sa gestire; php è in grado di gestire i seguenti tipi di dati:
- boolean
- integer
- double
- string
- array
- object
- resource
- NULL
Se volete ulteriori dettagli e informazioni sui tipi di dati disponibili in php vi consiglio di guardare la documentazione ufficiale. I dati vengono memorizzati in variabili. Una variabile non è altro che una locazione di memoria utilizzata per la memorizzare temporaneamente dati o informazioni. Le variabili in php vengono dichiarate utilizzando il prefisso dollaro ($). Tutti i nomi di variabili devono cominciare con una lettera o un underscore (_), è importante sottolineare che i nomi di variabili sono case sensitive, ossia $a non è uguale a $A. Un altro aspetto fondamentale, da tenere sempre a mente è che le variabili php non sono tipizzate di conseguenza è possibile assegnare alla stessa variabile tipi di dati differenti per esempio:
<?php
$prova = "ciao";
$prova = 3;le istruzione spora sono assolutamente valide, originariamente la variabile $prova è di tipo string, la riga successiva diventa di tipo integer. Pur non essendo un linguaggio tipizzato, php mette a disposizione la funzione gettype() che ci permette di conoscere il tipo di una variabile. Php consente anche di creare costanti ossia delle “variabili” particolari il cui valore non può cambiare. Vengono utilizzate per per memorizzare delle informazioni che non devono variare durante l’esecuzione del programma, vediamo un esempio auto esplicativo:
<?php
define('NOME_COSTANTE', 'VALORE'); // Definisco una constante
echo constant('NOME_COSTANTE'); // Stampo a video la costanteStringhe, numeri ed array
Vediamo ora nel dettaglio tre dei tipi di dati più utilizzati in php, le stringhe, i numeri (integer e double) e gli array.
Le stringhe non sono altro che una sequenza di caratteri (ASCII) racchiusi tra apici (virgolette), doppi ” o singoli ‘. L’utilizzo dei doppi apici permette a php di interpretare il contenuto di una strina, quindi ad esempio le variabili vengono inserite. Le stringhe possono anche essere concatenate utilizzando l’operatore di concatenazione (.), facciamo un semplice esempio:
<?php
$nome = 'Mario';
$cognome = 'Rossi';
$nome_completo = "$nome $cognome";
echo $nome_completo; // Output: Mario Rossi
// STESSO ESEMPIO CON OPERATORE .
echo $nome . $cognome; // Output: Mario RossiPhp offre una serie di funzioni “predefinite” molto comode che ci permettono di manipolare le stringhe, eccone alcune:
- strlen(), fornisce la lunghezza di una stringa.
- strtoupper(), trasforma una stringa il maiuscolo.
- strtolower($stringa), trasforma una stringa in minuscolo.
- substr(), permette di estrarre una sotto-stringa da una stringa.
- strpos(), trova la prima occorrenza di una stringa all’interno di un’altra.
Facciamo come di consueto un esempio per capire meglio:
<?php
// Definiamo una stringa
$stringa = "Ciao mondo!";
// Calcolo la lunghezza della stringa
echo strlen($stringa) . "\n"; // Output: 12
// Converte la stringa in lettere maiuscole
echo strtoupper($stringa) . "\n"; // Output: CIAO MONDO!
// Converte la stringa in lettere minuscole
echo strtolower($stringa) . "\n"; // Output: ciao mondo!
// Estrae una sottostringa dalla stringa
echo substr($stringa, 0, 4) . "\n"; // Output: "Ciao"
// Trova la prima occorrenza di una stringa all'interno di un'altra e ne ritorna l'indice.
echo strpos($stringa, "mondo") . "\n"; // Output: 6
Per maggiori informazioni riguardo alle funzioni, è utile guardare la documentazione. Dall’esempio si capisce anche come le stringhe sono una “tipologia speciale” di array (li vedremmo qui sotto), infatti quando utilizziamo la funzione substr, gli passiamo come parametri oltre alla stringa ($stringa), anche 0 e 4 che sono rispettivamente la posizione da cui iniziare ad estrarre nella stringa ed il numero di caratteri da estrarre. In pratica diciamo di estrarre dalla posizione zero, 5 caratteri; quindi una stringa può essere considerata come un array di caratteri.
Vediamo ora come funzionano i numeri in php, il tipo int rappresenta i numeri interi, senza virgola; mentre per i numeri in virgola mobile si utilizza il tipo double, la parte decimale dei numeri in virgola mobile è separata tramite punto (1.2345). Vediamo alcune delle principali operazioni matematiche in php tramite un semplice esempio:
<?php
// Addizione
$somma = 1 + 2; // $somma = 3
// Sottrazione
$differenza = 5 - 3; // $differenza = 2
// Moltiplicazione
$prodotto = 4 * 5; // $prodotto = 20
// Divisione
$quoziente = 10 / 2; // $quoziente = 5
// Modulo (resto della divisione)
$resto = 11 % 3; // $resto = 2
// Potenza
$potenza = 2 ^ 3; // $potenza = 8È inoltre possibile incrementare o decrementare i numeri vediamo come:
<?php
$numero = 0;
echo $numero++; // A video viene stampato: 0 poi il valore viene incrementato
echo $numero; // Viene stampato: 1
// è possibile anche incrementare prima il numero e poi stamparlo
echo ++$numero; // Viene stampato: 2
// N.B. Lo stesso vale anche per la sottrazioneCome per le stringhe, anche per i numeri, php mette a disposizione varie funzioni, ecco le più utili:
- sqrt(), calcola la radice quadrata di un numero.
- abs(), Ritorna il valore assoluto di un numero.
- round(), Arrotonda un numero al numero intero più vicino(se la parte decimale è >= 0.5 viene arrotondato al numero successivo se non diversamente indicato).
- floor(), Rimuove la parte decimale da un numero.
- ceil($numero), Trasforma $numero al numero intero successivo, arrotondandone la parte decimale.
- max(): Restituisce il valore massimo tra due o più numeri (è possibile passare anche un array).
- min(): Restituisce il valore minimo tra due o più numeri (è possibile passare anche un array).
<?php
// Radice quadrata
$radice = sqrt(9); // $radice = 3
// Valore assoluto
$valoreAssoluto = abs(-5); // $valoreAssoluto = 5
// Arrotondamento
$numeroArrotondato = round(3.14); // $numeroArrotondato = 3
// Arrotondamento inferiore
$arrotondamento_inferiore = floor(3.14); // $arrotondamento_inferiore = 3
// Arrotondamento superiore
$arrotondamento_superiore = ceil(3.14); // $arrotondamento_superiore = 4
// Valore massimo
$massimo = max(1, 2, 3); // $massimo = 3
// Valore minimo
$minimo = min(array(1, 2, 3)); // $minimo = 1Un array in PHP è una collezione ordinata di dati. Può contenere qualsiasi tipo di dato, inclusi numeri, stringhe, booleani, altri array e oggetti. In php è possibile definire un array nei seguenti modi:
<?php
$array = array(1, 2, 3, "ciao", true); // Creazione di un array tramite il costrutto array
//oppure
$array2 = [1, 2, 3, "ciao", true]; // Creazione di un array tramite parentesi quadrePer accedere ad un elemento dell’array è possibile utilizzare l’indice, in quanto gli elementi sono memorizzati in sequenza rispettando l’ordine d’inserimento, il primo indice è zero, vediamo un esempio di come accedere all’elemento “ciao” dell’array sopra:
<?php
$array = [1, 2, 3, "ciao", true];
echo $array[3]; // Output: Ciaoper aggiungere un elemento in coda a quelli già presenti in un array è possibile utilizzare la funzione array_push oppure la sintassi con le parentesi quadre [], se si aggiunge un solo elemento è meglio utilizzare la sintassi con parentesi quadre in quanto non c’è il sovraccarico della chiamata della funzione:
<?php
$mesi = [“Gennaio”, “Febbraio”];
array_push($mesi, “Marzo”, “Aprile”);
$mesi[] = “Maggio”;
var_dump($mesi);
/* Output:
Array
(
[0] => Gennaio
[1] => Febbraio
[2] => Marzo
[3] => Aprile
[4] => Maggio
)
*/
In questo esempio abbiamo visto anche l’utilizzo della funzione var_dump() che permette di stampare a video il tipo ed il valore di una variabile, molto utile per scopi di debug. È anche possibile modificare il valore di un elemento di un array, ad esempio dato questo array: $automobili = [“BMW”, “ADIDAS”, “MERCEDES”, “FIAT”, “ALFA”] possiamo modificare l’elemento “ADIDAS” con indice 1 facendo $automobili[1] = “LANCIA”. Ecco alcune delle funzioni fornite da php per gestire gli array:
- count(), Ritorna il numero di elementi presenti in un array.
- sort(), Ordina gli elementi di un array in ordine crescente o alfabetico.
- rsort(), Ordina gli elementi di un array in ordine inverso.
- in_array(), Verifica se un valore è presente in un array.
- array_push(), Aggiunge un elemento alla fine di un array.
- array_pop(), Rimuove l’ultimo elemento da un array.
- array_shift(), Rimuove il primo elemento da un array.
- array_unshift(), Aggiunge un elemento all’inizio di un array.
Vediamo un esempio pratico:
<?php
$array = ["uno", "due", "tre"];
echo $array[0]; // "uno"
echo $array[1]; // "due"
echo $array[2]; // "tre"
$numeroElementi = count($array); // 3
// Ordina gli elementi di un array
sort($array);
// Verifica se un valore è presente in un array
$valorePresente = in_array("ciao", $array);
// Aggiunge un elemento alla fine di un array
array_push($array, "quattro");
// Rimuove l'ultimo elemento da un array
array_pop($array);
// Rimuove il primo elemento da un array
array_shift($array);
// Aggiunge un elemento all'inizio di un array
array_unshift($array, "zero");Fino ad ora abbiamo visto esempi di array accessibili solo tramite indici numerici, come molti altri linguaggi php mette a disposizione anche gli array associativi. Un array associativo in PHP è un array in cui gli elementi sono accessibili tramite chiavi anziché indici numerici. Le chiavi possono essere stringhe o numeri, vediamo subito un esempio:
<?php
$array = [
"nome" => "Mario",
"cognome" => "Rossi",
"età" => 30
];Istruzioni Condizionali
Scrivendo codice capita a volte di dover eseguire una porzione di codice solo al verificarsi di una determinata condizione, è qui che entrano in gioco le istruzioni condizionali. In php sono definite attraverso l’uso delle parole chiave “if“, “else if” ed “else” come in molti altri linguaggi di programmazione. Vediamo un esempio di codice che spiega come funzionano:
<?php
$ph = 7;
if($ph < 7) {
echo "Il ph è acido\n";
}else if($ph == 7) {
echo "Il ph è corretto";
}else {
echo "Il ph è alcalino";
}
Di seguito è riportata la tabella con la maggior parte degli operatori di confronto di php:
| Operatore | Descrizione |
|---|---|
| == | Uguale a |
| === | Uguale a (tipo di dati identici) |
| != | Diverso da |
| <> | Diverso da |
| !== | Diverso da (tipo di dati identici) |
| < | Minore di |
| > | Maggiore di |
| <= | Minore o uguale a |
| >= | Maggiore o uguale a |
Tabella degli operatori di confronto
Oltre agli operatori di confronto sono disponibili anche gli operatori logici, che permettono di concatenare più condizioni:
| Operatore | Descrizione |
|---|---|
&& o and | AND – restituisce true se entrambe le condizioni sono vere |
xor | XOR – restituisce true se esattamente una delle condizioni è vera |
! o not | NOT – nega la condizione, restituisce true se la condizione è falsa |
Per maggiori sull’argomento consiglio di guardare la documentazione ufficiale.
Esiste anche una forma contratta dell’if in php (o operatore ternario), ed ha la seguente sintassi:
(espressione1) ? (espressione2) : (espressione3)Il punto interrogativo ? funge da then mentre i due punti : sono l’else quindi se l’espressione 1 risulta verificata, viene restituito il valore di espressione 2 altrimenti il valore di espressione 3. Vediamo un semplice esempio chiarificatore:
<?php
$name = isset($_SESSION['name']) ? $_SESSION['name'] : 'Sconosciuto';
?>Esiste anche un altro tipo di istruzione condizionale, questa è l’istruzione switch(), essa permette di suddividere i possibili casi o valori di una variabile, vediamo un esempio:
<?php
switch ($variabile) {
case valore1:
// istruzioni da eseguire se $variabile = valore1
break;
case valore2:
// istruzioni da eseguire se $variabile = valore2
break;
// altri casi possibili
default:
/* istruzioni da eseguire se $variabile non corrisponde a nessuno dei casi precedenti */
}
?>Cicli Iterativi
Php mette a disposizione 3 cili iterativi:
- Ciclo While
- Ciclo do While
- Ciclo For
Il ciclo While viene eseguito finché una determinata condizione risulta vera, ecco un piccolo esempio per capirne la sintassi:
<?php
$i = 0;
while($i <= 3) {
echo "Prova";
$i++;
}
echo "Fine: ".$i;
?>In questo esempio, il ciclo while continua ad eseguire il codice al suoi interno, ossia stampare a video la scritta “Prova” (echo “Prova”;) ed incrementare la variabile $i ($i++; = $i = $i+1;), fino a quando la condizione $i <= 3 (la variabile $i è minore o uguale a 3) è vera; quando tale condizione non risulta più verificata, il ciclo while si interrompe e viene stampata la scritta fine con la variabile $i che sarà uguale a 3.
Il ciclo do while è simile al ciclo while, l’unica differenza sta nel fatto che la condizione è posta alla fine dell’iterazione, quindi prima viene eseguito il codice. Vediamo la sintassi:
do {
// istruzioni da eseguire
} while (condizione);Il ciclo for è una delle istruzioni più utilizzate di php, la sua sintassi è la seguente:
for(inizializzazione; condizione; espressione) { //Istruzioni da eseguire }
dove inizializzazione è un istruzione che viene eseguita all’inizio del ciclo, condizione è l’istruzione condizionale eseguita all’inizio di ogni iterazione ed espressione è l’istruzione che viene eseguita al termine di ogni iterazione. Vediamo l’esempio del ciclo while fatto con il ciclo for per capire meglio:
<?php
for($i=0; $i <= 3; $i++) {
echo "Prova";
}
echo "Fine";
?>L’esempio sopra riportato è simile a quello del ciclo while fatto in precedenza, l’unica differenza sta nel fatto che alla fine del ciclo (una volta usciti) non è possibile stampare il valore della variabile $i concatenato alla parola “Fine” in quanto la variabile $i viene distrutta poiché interna al cioclo. Php offre una versione particolare del ciclo for (foreach) utilizzata per iterare sugli elementi degli array. L’istruzione foreach ha 2 varianti di sintassi a seconda che si tratti di array semplici o associativi vediamole:
foreach($array as $valore) {
/* In questo caso il ciclo crea una variabile temporanea interna ($valore) per stampare il valore dell'iterazione corrente di $array. */
}
oppure
foreach($array as $chiave => $valore) {
/* In questo caso il ciclo crea 2 variabili temporanee una $chiave che contiene la chiave dell'array associativo e l'altra $valore che contiene il valore della chiave per l'iterazione corrente. */
}Break e continue sono due istruzioni che consentono rispettivamente di interrompere e saltare l’iterazione di un ciclo. Sono istruzioni particolari che possono anche compromettere il codice se non usate correttamente. Per maggiori informazioni sui cicli si rimanda alla documentazione ufficiale.
Funzioni
Le funzioni non sono altro che un insieme di istruzioni richiamabili attraverso una sola riga di codice. Abbiamo già visto alcune funzioni native di php come gettype(), è possibile anche crearne di personalizzate. Le funzioni definite dal programmatore possono ricevere uno o più parametri in ingresso e restituire un valore di output, vediamone la sintassi:
function nome(parametri) {
// Codice
return $valore;
}nome è il nome della funzione, parametri sono i parametri della funzione, al posto del commento codice è possibile inserire il codice che la funzione deve eseguire, attraverso l’ultima riga return $valore; è possibile specificare un valore che la funzione deve restituire quando eseguita. Vediamo un esempio di codice in cui dichiariamo una funzione che prende in ingresso un array di numeri e ne esegue la somma:
<?php
function somma_array($array_numeri) {
$somma = 0;
foreach ($array_numeri as $numero) {
$somma += $numero;
}
return $somma;
}
// chiamata della funzione somma_array
$numeri = array(1, 2, 3, 4, 5);
$risultato = somma_array($numeri);
echo $risultato; // output: 15
Alle funzioni php è possibile passare dei parametri opzionali quali argomenti di una funzione per rendere opzionale un parametro è necessario assegnargli un valore di default per esempio la funzione seguente accetta come parametro opzionale un array:
<?php
function prova(int $valore, array $opzioni=[]){}
prova(2);
prova(1, [1,2]);entrambe le invocazioni alla funzione sono corrette in quanto il parametro $opzioni è opzionale, i parametri opzionali devono essere sempre gli ultimi nell’elenco dei parametri di una funzione in quanto altrimenti ci potrebbero essere comportamenti inattesi. Oltre alla possibilità di specificare parametri opzionali ad una funzione php permette di specificare un numero indefinito di valori in ingresso tramite l’operatore variadic (…) facciamo un esempio auto esplicativo:
<?php
function somma(...$numeri) {
$somma = 0;
foreach ($numeri as $numero) {
$somma += $numero;
}
return $somma;
}
// chiamata della funzione somma con 3 argomenti
echo somma(1, 2, 3); // output: 6
// chiamata della funzione somma con 5 argomenti
echo somma(1, 2, 3, 4, 5); // output: 15
In PHP, le funzioni anonime (o “closure”) sono funzioni senza nome, che possono essere utilizzate per creare funzioni “inline” (funzioni di callback) o passare funzioni come argomenti ad altre funzioni. Le funzioni anonime sono utili quando si ha bisogno di definire una funzione ad hoc senza doverla dichiarare in una classe o in un file separato. Le funzioni anonime sono utili anche per passare funzioni come argomenti ad altre funzioni; vediamo un esempio:
<?php
// creazione di una funzione anonima che restituisce il doppio del valore passato come parametro
$doppio = function($valore) {
return $valore * 2;
};
// utilizzo della funzione anonima
echo $doppio(5); // output: 10
Con l’avvento di php 7 è possibile la gestione dei tipi in ingresso ed in uscita dalle funzioni, ciò significa che è possibile specificare il tipo di dato che deve essere passato come parametro alla funzione e il tipo di dato che la funzione deve restituire. Per specificare il tipo di dato in ingresso, si può utilizzare la sintassi di dichiarazione dei tipi nella definizione della funzione. Ad esempio, la seguente funzione accetta un parametro $numero di tipo “integer”:
<?php
function quadrato(int $numero) {
return $numero * $numero;
}
In modo simile, si può specificare il tipo di dato in uscita dalla funzione utilizzando la sintassi di dichiarazione dei tipi. Ad esempio, la seguente funzione restituisce un valore di tipo “float”:
<?php
function divisione(float $a, float $b): float {
return $a / $b;
}
È importante notare che la tipizzazione dei dati in ingesso ed in uscita dalle funzioni non è obbligatoria e può essere abilitata con declare(strict_types=1); e disabilitata con declare(strict_types=0); .
É inoltre possibile utilizzare il tipo nullable che offre possibilità che un parametro possa avere anche il valore “null” oltre ai valori del tipo di dato specificato. Questo tipo di dato viene indicato anteponendo il simbolo “?” prima del tipo di dato. Ad esempio, il tipo “?string” indica che la variabile può essere di tipo “string” o “null”. Vediamo un semplice esempio:
<?php
function stampaStringa(?string $stringa) {
if ($stringa !== null) {
echo $stringa;
} else {
echo "La stringa è vuota";
}
}
stampaStringa("Ciao Mondo!"); // Output: Ciao Mondo!
stampaStringa(null); // Output: La stringa è vuota
N.B. Per quanto riguarda il tipo array non è possibile specificare il tipo degli elementi di un array. Ad esempio non è possibile specificare un array di interi.
Lascia un commento