Guida PHP in Italiano

PHP (acronimo ricorsivo per : Hypertext Preprocessor) è nato come piccolo progetto open source nel 1994, dal programmatore danese Rasmus Lerdorf. Inizialmente scritto con il linguaggio di programmazione C, venne utilizzato dal creatore per tenere traccia delle visite sul suo curriculum online. Con il tempo, mosso dal desiderio di un progetto che avesse più funzionalità, Rasmus scrisse PHP Tools. Questa nuova versione permetteva di interagire con i database, fornendo così un framework su cui gli utenti potevano sviluppare semplici applicazioni web dinamiche.  Il codice sorgente venne reso pubblico nel giugno del 1995, permettendo agli sviluppatori di utilizzarlo in maniera autoctona, e agli utenti di fornire correzioni per i bug nel codice e di migliorarlo in generale.  Il codice ha subito un restyling completo nell’Aprile del 1996 (con il nome di PHP/Fi), permettendo un’evoluzione di PHP da suite di strumenti a linguaggio di programmazione a sé stante, comprendendo il supporto integrato per database, cookies e funzioni definite dall’utente. Soltanto con l’arrivo di PHP 3.0 nel Giugno del 1998, grazie alla collaborazione di Zeev Suraski e Andi Gutmans, si consolidò uno dei suoi maggiori punti di forza, ovvero le forti caratteristiche di estensibilità (per estensibilità si intende la possibilità di interagire con altri linguaggi o database). Inoltre, è stata fornita agli utenti un’interfaccia più matura per database, protocolli ed API (application programming interface). Con molta probabilità, questa è stata la chiave dell’enorme successo della versione 3.0 di PHP. Ulteriori caratteristiche chiave includono il supporto alla programmazione orientata agli oggetti e una sintassi del linguaggio di programmazione molto più potente. Nei giorni odierni PHP è particolarmente adatto per lo sviluppo Web; essendo esso un linguaggio interpretato, ha la possibilità di essere incorporato in HTML. Cosa intendiamo quando parliamo di linguaggio interpretato? Andiamo a scoprirlo! Linguaggi interpretati e compilati  Un linguaggio compilato è un linguaggio di programmazione in cui il codice sorgente viene tradotto in codice macchina; questa procedura viene detta compilazione.  Successivamente, il linguaggio compilato viene archiviato in un file separato detto eseguibile, ad esempio il classico .exe di Windows. Questo tipo di linguaggio tende a dare allo sviluppatore web un controllo maggiore sugli aspetti hardware, come l’utilizzo della CPU e la gestione della memoria. In un linguaggio compilato, il programma deve essere ricompilato ogni volta che si apporta una modifica. Esempi di linguaggi compilati : C, C++, Rust e Go. Un linguaggio interpretato è un linguaggio di programmazione che vede la maggior parte della sua implementazione eseguire istruzioni direttamente, senza compilare prima un programma in codice macchina. L’interprete esegue il programma direttamente, traducendo ogni istruzione in sequenze di uno o più sottoprogrammi, e poi in codice macchina. Esempi di linguaggi interpretati: PHP, HTML, Python e JavaScript.   Vantaggi e svantaggi I programmi interpretati sono più lenti dei programmi compilati in codice nativo: questo è dovuto al processo di traduzione in fase di esecuzione, che aumenta il sovraccarico e può causare un rallentamento generale del programma. I linguaggi di programmazione interpretati sono, tendenzialmente, più flessibili ed offrono innumerevoli funzionalità aggiuntive come le dimensioni del codice ridotte e la digitazione automatica.  Gli svantaggi più considerevoli per i linguaggi compilati riguardano il tempo necessario per il completamento della fase di compilazione e la dipendenza dal codice binario generato, mentre, per i linguaggi interpretati lo svantaggio si focalizza sempre sulla velocità di esecuzione inferiore.   Perchè imparare PHP: i vantaggi La popolarità di PHP è logicamente dovuta ai suoi numerosi vantaggi, che lo rendono uno strumento potente ed efficace per lo sviluppo web. Tra questi motivi possiamo trovare: ampia disponibilità di materiali di riferimento; una vasta raccolta di componenti open source; grande sinergia con il linguaggio HTML; flessibilità e combinabilità; opzioni per la connettività con i database; velocità di caricamento dei siti web; Svisceriamo un po’ i vari punti: Ampia disponibilità di materiali di riferimento Sul Web sono disponibili molti tutorial, manuali e diversi manuali di riferimento che semplificano lo sviluppo e possono ispirare ed aiutare in situazioni di difficoltà. Si tratta di materiali preziosi soprattutto per gli sviluppatori alle prime armi che vogliano iniziare a programmare, poiché semplificano ulteriormente il processo di apprendimento di un linguaggio di programmazione già semplice di per sé.   Una vasta raccolta di componenti open source Essendo PHP una tecnologia free-to-use presenta notevoli risparmi per il budget di sviluppo. In più, la maggior parte degli strumenti utilizzati per sviluppare in ausilio a PHP sono framework open source ed utilizzabili gratuitamente riducendo ancora il costo dello sviluppo. Inoltre, esistono anche framework come Laravel, che estende le funzionalità di PHP e rende possibile sviluppare in maniera più efficace e semplice.  Grande sinergia con il linguaggio HTML Come già detto in precedenza, PHP offre la programmazione incorporata in HTML. Nella maggior parte dei casi, uno script PHP non interferisce con il codice html di una pagina web, e, anzi, lo completa rimanendo nei bordi definiti dal tag <?php ?>. <!DOCTYPE html> <html lang="it"> <head> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatibile" content="IE=edge"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Document</title> </head> <body> <?php echo "Ciao a tutti"; ?> </body> </html> Viceversa, in una pagina PHP puoi integrare codice HTML usando uno script. Flessibilità e combinabilità PHP è in grado di combinarsi efficacemente con molteplici linguaggi, in modo che il software possa utilizzare la tecnologia più efficace per ogni caratteristica.  Opzioni per la connettività con i database PHP consente la connessione con molteplici database. La scelta più comune è Mysql, molto efficace e popolare tra i developer. Altre solide opzioni possono essere PostgreSQL, MongoDB, e SQLite (che, però, è specifico per ambienti di test). In questo modo gli sviluppatori web non si limitano a utilizzare un determinato database e possono selezionare quello più performante per un’app futura, tenendo in considerazione tutti i fattori rilevanti. Velocità di caricamento dei siti web L’utilizzo di PHP rende la pagina web più veloce rispetto a molte tecnologie di sviluppo web. Anche il minor tempo di caricamento è un importante fattore per il ranking SEO (Ottimizzazione per i motori di ricerca) per promuovere la propria pagina web e renderla più competitiva. Una migliore velocità rende i clienti soddisfatti e aiuta a costruire e mantenere la base di clienti.

Prima di addentrarci nella teoria, ti suggeriamo di installare PHP sul tuo computer, in modo tale da poter testare in prima persona il codice e poterti, via via, esercitare (anche grazie ai nostri esercizi PHP per skillarti!) Segui questa guida per procedere all'installazione: ci vorranno solo pochi minuti! Come installare PHP su Windows Vai al seguente link per scaricare i file di installazione: PHP: Downloads   Scarica il file zip dell'ultima versione stabile Una volta scaricato il file apri la cartella C:/ nell'esplora risorse del tuo pc e crea una cartella chiamata php All'interno della cartella php appena creata crea un'altra cartella con il numero della versione di php, nel nostro caso 8.1. Una volta fatto questo estrai il contenuto del file zip e inseriscilo all'interno della cartella C:\php\8.1\ Il risultato finale dovrebbe essere simile a questo : Manca poco! Adesso dobbiamo inserire all'interno delle variabili d'ambiente del sistema la cartella di php appena creata. Apri il menù di windows e cerca all'interno della barra di ricerca "Variabili di ambiente relative al sistema". Una volta aperto il menù dovresti visualizzare questa schermata: Apri la  tab del menù "avanzate" e clicca in basso a desta il tasto "Varibili d'ambiente"   Nella sezione relativa alle variabili di sistema cerca la voce Path e clicca due volte per aprirla   Clicchiamo sul tasto nuovo e andiamo ad inserire il percorso della cartella 8.1 di php C:\php\8.1   Avremo questo risultato, se hai rinominato le cartelle in modo diverso inserisci il percorso corretto. Fai attenzione ad inserire anche minuscole e maiuscole in modo identico.   Clicchiamo su OK per confermare le modifiche Verifichiamo adesso che php sia correttamente installato sul nostro sistema. Apri un terminale (PowerShell o Git Bash) e digita il comando php -v, dovrebbe ora uscirti la versione di php installata. In caso ti esca un errore relativo  alla libreria 140.dll scarica il seguente file e avvia l'eseguibile scaricato. Download di Visual C++ Redistributable supportati più recenti | Microsoft Docs   Una volta installato il programma chiudi tutti i terminali aperti e riprova a lanciare il comando php -v nella console. Come installare PHP su Mac Per installare php all'interno del tuo Mac avrai bisogno di scaricare e installare il gestore di pacchetti per mac HomeBrew, se lo hai già installato salta la prima parte. Download e installazione HomeBrew: Per scaricare HomeBrew puoi seguire la guida del sito ufficiale : Apri un terminale sul tuo mac e lancia questa riga di comando : /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)" Una volta terminata l'installazione di HomeBrew chiudi tutti i terminali e apri un nuovo terminale. Per installare php ti basterà lanciare questo comando nel terminale : brew install php Una volta terminata l'installazione lancia il comando php -v nel terminale per verificare la versione installata e per verificare che sia andato tutto a buon fine. È fatta! Pronto a cominciare?

Nel capitolo precedente ti abbiamo spiegato come installare php se per qualsiasi motivo non avessi voglia o la possibilità di farlo esistono tanti editor online che ti permettono di eseguire e testare del codice php direttamente sul tuo browser preferito. Seguendo i seguenti passaggi potrai utilizzare un compilatore online di php: Apri il tuo browser preferito e vai all'indirizzo https://phpsandbox.io/. Questo è il punto di partenza per iniziare a scrivere e testare il tuo codice PHP. Ci sono molti compilatori online tra cui scegliere, noi abbiamo scelto questo che  ha un'interfaccia molto intuitiva e user friendly. Una volta caricato il sito, procediamo con la creazione del nostro primo progetto, per farlo dovremo come prima cosa effettuare l'accesso o l'iscrizione. Clicchiamo quindi su create notebook e selezioniamo il tipo di template per il nostro progetto. Nel nostro caso selezionaremo il template standard di PHP Una volta creato il progetto ci si presenterà questa schermata: Nella sezione sinistra dell'editor possiamo selezionare la seconda tab del file explorer per visualizzare tutti i file del progetto. Nella sezione in alto a destra troviamo i tasti per aggiungere altri file e cartelle. Nella sezione centrale trovaimo invece l'editor di testo e la sezione della preview del codice Cancelliamo tutto il contentuto del file index.php e proviamo a inserire il seguente codice <?php echo "Ciao, mondo!"; ?> Una volta che hai scritto il tuo codice PHP, premi il pulsante con la freccia nella sezione della preview per ricaricare la pagina e visualizzare il risultato del codice. Questo farà sì che il compilatore online esegua il tuo codice e mostri i risultati nell'area di output a destra. Nella sezione in basso troviamo anche la parte dei logs nella quale verranno visualizzati tutti log non visibili sul browser. Ora che hai eseguito con successo il tuo primo codice PHP, puoi iniziare a sperimentare ulteriormente. Prova a scrivere codice più complesso, utilizzare variabili, cicli e condizioni per creare programmi più avanzati.

Ora che abbiamo conosciuto un po' PHP e ne abbiamo valutato i vantaggi, prima di addentrarci nel vivo di questo linguaggio di programmazione è il caso di chiarire alcune nozioni di base utili alla sua comprensione. Iniziamo col presentare un concetto perno di tutti i linguaggi di programmazione, imprescindibile per il loro apprendimento: quello di “variabile”. Se bazzichi un po’ il mondo della programmazione informatica, ne avrai, senza dubbio, sentito parlare. Ma che cos’è una variabile? Una variabile corrisponde ad una porzione di memoria in cui viene scritto un dato di qualsiasi tipologia.  In altre parole, potremmo paragonare una variabile ad una sorta di “contenitore” al cui interno vengono salvati dei dati.  È doveroso capire cosa potrebbe essere classificato in quanto dato. I dati sono tutte le informazioni digitali che abbiamo a disposizione o che verranno create per raggiungere il nostro scopo, cioè quello di risolvere un problema. In ogni contenitore - dunque in ogni variabile - viene inserito un dato caratterizzato dalla sua tipologia (in altre parole, una sua caratteristica intrinseca che lo contraddistingue dagli altri tipi di dato).  Proviamo a capire meglio questo concetto grazie all’aiuto di una metafora. Immagina che le nostre variabili siano i cassetti di una cassettiera. Ogni cassetto contiene una tipologia di indumento: ci sarà un cassetto per i calzini, un cassetto per gli indumenti intimi, uno per le t-shirt e così via. È naturale supporre che non potremo mai utilizzare un calzino al posto di una t-shirt, in quanto la sua caratteristica intrinseca è, in questo caso, lo scopo cui è destinato: coprire i piedi.  Non puoi utilizzare un calzino per coprire il busto, o le braccia, giusto? Bene! Gli indumenti sono i nostri dati, suddivisi per tipologia. Ora, il valore del dato in questione puo’ variare durante l’esecuzione del programma o puo’ rimanere lo stesso per tutta la sua durata. Fatte queste premesse, i linguaggi di programmazione si suddividono in due grandi famiglie in base a come vengono create e gestite proprio queste variabili: linguaggi a tipizzazione forte e linguaggi a tipizzazione debole   Tipizzazione forte e tipizzazione debole. Nei linguaggi a tipizzazione forte, ogni variabile viene creata dichiarando quale tipo di dato questa debba contenere. Questa informazione rimarrà invariata per tutto il ciclo di vita del programma. Riprendiamo l’esempio poco più sopra: nei linguaggi a tipizzazione forte ogni cassetto ha una sorta di “etichetta” che definisce quale tipologia di indumento può esservi inserita. E questa etichetta sancirà l’utilizzo di quel cassetto per quel tipo di indumento fino alla fine del ciclo del programma. Ci spieghiamo ancora meglio: una variabile che viene dichiarata come contenitore per un numero intero - che è un tipo di dato - ad esempio, potrà contenere solo e soltanto un numero intero al suo interno (1,34,56,4,37,1000 ecc).  Vediamo un esempio utilizzando Java, uno dei linguaggi a tipizzazione forte più conosciuti; dichiariamo due variabili: public class HelloWorld{ public static void main(String[] args) { String primo_dato = "5"; //é una stringa con un solo carattere che assume il valore di cinque int secondo_dato = 5; //é un numero intero System.out.println("Primo dato"+primo_dato+"\n"); System.out.println("Secondo dato"+secondo_dato+"\n"); } } //IN OUTPUT //Primo dato 5 //Secondo dato 5 Analizziamo le due variabili: La prima variabile contiene una stringa, la seconda contiene un numero intero. La variabile "primo dato" non sará MAI uguale alla variabile "secondo dato" e non potremo MAI "cambiare" il contenuto di "primo dato" in un numero intero, così come non potremo MAI "cambiare" il valore di "secondo dato" in una stringa. Questa è proprio la peculiarità di un linguaggio a tipizzazione forte. Dichiariamo sin dall’inizio quale tipo di dato conterrà una variabile ed il suo contenuto sarà sempre di quel tipo. Quindi potremo sostituire una stringa con un’altra stringa ma mai con un numero. Quando dichiariamo una variabile, con il relativo tipo, e salviamo un valore al suo interno,  la stiamo INIZIALIZZANDO.    Nei linguaggi a tipizzazione debole, invece, possiamo cambiare il valore contenuto all’interno di una variabile sostituendolo con un tipo di dato differente.  Sarà, dunque, possibile svuotare il cassetto dei calzini e inserirci le tue t-shirt preferite! Quindi, una variabile che, in un determinato momento, contiene una stringa, in un altro momento può contenere un numero intero o un qualsiasi altro tipo di dato. PHP è un linguaggio a tipizzazione debole.   TIPI DI DATO Veniamo, ora, al nocciolo della questione: andiamo a classificare i TIPI di dato. Il tipo di un dato e’ caratterizzato due informazioni: il valore stesso e le operazioni con cui possiamo manipolarlo.  Un numero, ad esempio, puo’ contenere tutti i valori che vanno da -∞ a +∞ e puo’ essere manipolato tramite le operazioni logico-matematiche. Una stringa, invece, e’ una sequenza di caratteri alfanumerici e speciali su cui possiamo effettuare operazioni di conteggio, concatenazione, ecc… In PHP ci sono 10 tipi di dato: Integer Float String Boolean Array Object Callable Iterable NULL Resource Di questi, ne analizzeremo 7 - i più utilizzati - che divideremo in tre famiglie: DATI SEMPLICI: Integer, Float, String, Boolean DATI SPECIALI: NULL DATI COMPOSTI: Array ,Object Integer (interi) 0, 5, 46, 130, 980, 1000 e via discorrendo, come anche -1, -13, -56, -100, -765, -1000 ma anche molti altri (e per questi consigliamo di far riferimento alla documentazione ufficiale dovessero essere di nostro interesse). Gli integer, in sostanza, sono tutti numeri INTERI positivi o negativi. Float (numeri in virgola mobile, in inglese “Floating point o Double”) Si riferisce a quella tipologia di numero non intero, cioè che contiene una virgola definita mobile perché si "sposta", ovvero la vedremo in posizioni "diverse" in base alla “precisione”, cioè alla quantità di numeri presenti dopo la virgola. Per esempio: 1,1 ha precisione uno 23,72 ha precisione due 5,576 ha precisione tre, e così via. Con il tipo float, tuttavia, si indicano anche altre tipologie di numeri: rimandiamo sempre alla documentazione ufficiale PHP per maggiori dettagli. String (testi o stringhe di caratteri) Il tipo di dato stringa è un insieme di caratteri espressi tra apici. "Questa è una stringa" o, anche, "quESta è UNA stRInga" e persino "1223429 12489 4058934" sono tre semplici esempi di stringhe, di insieme di caratteri.  Il terzo esempio, peró, potrebbe confonderti: se è un insieme di numeri, come puo’ essere considerato una stringa? La spiegazione è già nella definizione: come abbiamo già detto, una stringa é un insieme di caratteri alfanumerici racchiusi tra apici (‘’) o doppie virgolette (“”). Senza i sopracitati apici quella successione di numeri sarebbe stata considerata un tipo di dato integer. Boolean (valori booleani true/false) E' un tipo di dato che può esprimere solo due valori: vero o falso. Due o piú numeri sono uguali? Due o piú parole sono uguali? Esiste una parola in una frase? Esiste una lettera in una frase? Un dato ha assunto un certo valore? Queste domande sono assai esemplificative: avranno, all'interno del linguaggio, proprio una risposta del tipo Vero o Falso.   Null (tipo di dato nullo) Il valore speciale null si riferisce ad una variabile senza alcun valore. Null in PHP è considerato un tipo di dato. Array ed oggetti Prima di andare avanti, facciamo una piccola premessa: solitamente, nei linguaggi di programmazione orientati agli oggetti tutte le tipologie di dati composti sono figli di un genitore chiamato Object (Oggetto) e gli array ne fanno parte.  In PHP, invece, gli array non sono figli di Object. Array ed Oggetti, quindi, sono, in PHP, due cose differenti. PHP Array Un array è un insieme ordinato di elementi che possono appartenere ad una qualsiasi delle tipologie descritte sopra; un array, infatti, può contenere al suo interno persino ulteriori array o oggetti. Gli array si suddividono in due tipologie:  Array semplici  Array associativi Abbiamo definito l’array un insieme ordinato proprio per delineare la differenza tra le due tipologie:  nel caso dell’ array semplice, ogni qualvolta inseriamo un nuovo elemento, questo riceve una posizione numerica; il primo elemento avra’ posizione 0 (PHP viene definito un linguaggio di programmazione zero-based) e gli altri seguiranno in maniera crescente. Questo numero, che indica la posizione degli elementi, si chiama indice. L’array associativo ha una differenza fondamentale rispetto all’array semplice: ad ogni elemento non viene più assegnato un numero ma una sua “caratteristica” detta “chiave” e, proprio in base a questa, prenderà posto all’interno dell’array in ordine di arrivo (inserimento). Questo tipo di array è noto anche come “array chiave-valore” e la chiave in questione sarà sempre una stringa.  PHP Object Un oggetto e’ un tipo di dato che ci permette di descrivere un nuovo elemento partendo dalle sue caratteristiche.  Ad esempio, se creiamo un oggetto che identifica una persona, questo avra’ come caratteristiche quelle che identificano, appunto, una persona: nome, cognome, eta’, altezza, colore di capelli, ecc..  Queste caratteristiche possono essere definite dal developer in modo da descrivere al meglio il dato che vuole rappresentare.  Gli oggetti, a differenza degli altri tipi di dato, possono implementare delle funzioni: delle vere e proprie azioni che caratterizzano il comportamento del dato che stiamo creando.  Un oggetto che definisce una Persona, ad esempio, puo’ implementare una funzione che gli permette di dire il suo nome, il suo cognome e la sua età.

Prima di proseguire la nostra esplorazione nel mondo del linguaggio di programmazione PHP, ci soffermeremo sui due modi che abbiamo per manipolare i dati al suo interno.  La prima modalità prevede l’utilizzo delle variabili, di cui abbiamo parlato nell' articolo precedente, ma delle quali abbiamo trascurato la sintassi: rimediamo subito! La prima cosa che devi sapere quando ti approcci all' imparare php, è che le variabili in PHP si dichiarano con il $ seguito da un nome a nostra scelta, ma che ne descriva il più possibile il contenuto, un po' come accadeva per le classi parlanti del linguaggio CSS. Ricordi?  <?php $welcome_message="Hello world"; ?> Abbiamo creato una variabile che al suo interno ha un insieme di caratteri definito stringa che compone la parola “Hello world”. Vediamo alcune regole sul nome della variabile: Deve iniziare con il $ Deve iniziare con una lettera o con un _ Non puó iniziare con un numero Può contenere caratteri alfanumerici o _ Non può contenere spazi vuoti (a differenza, come vediamo nell’esempio, del suo valore di tipo stringa) Come abbiamo anticipato, PHP è tra i linguaggi di programmazione a tipizzazione debole e questo vuol dire che possiamo fare questo  <?php $hello="Hello"; echo $hello; $hello=123; echo $hello; ?> nb. PHP echo è il comando che serve a stampare in console un output. Lanciando il programma, vedremo che inizialmente ci restituirà come output Hello e, in seguito, 123. Cosa è successo?La colpevole è proprio la tipizzazione debole di PHP, che ci consente di cambiare a nostro piacimento il contenuto di qualsiasi variabile. Abbiamo, tuttavia, un modo per bloccare il contenuto di una locazione di memoria: utilizzare le costanti. Le costanti sono contenitori il cui contenuto non cambia mai, né può cambiare. Se provassimo a cambiarlo ci verrebbe restituito un errore. Una costante si dichiara utilizzando la keyword “const” seguita dal nome senza $. <?php const HELLO ="Hello"; HELLO=123; ?> In output avremo: Come ci aspettavamo, non essendo possibile cambiare il contenuto di una costante, in output ci è stato segnalato un errore. Facciamo anche un’altra osservazione: il nome della costante, come evidente nell’esempio, è tutto in maiuscolo. Le costanti vanno sempre create con nome tutto in maiuscolo. Si potrebbe scriverle tutte in minuscolo, non ci verrebbe segnalato un errore, verrebbe sempre trattata come una costante, ma è convenzione riconosciuta globalmente che siano in maiuscolo.

Caratteristica comune a tutti i linguaggi di programmazione - e, dunque, propria anche di PHP - oltre alle variabili, è quella degli operatori.  Potremmo immaginare un operatore come una piccola scatola magica in cui inseriremo qualcosa - i nostri operandi - e ne tireremo fuori qualcosa di diverso rispetto a quello che abbiamo inserito - il nostro risultato -.  Gli operatori, quindi, eseguono un’operazione avendo a disposizione degli operandi. Ne analizzeremo tre tipologie: operatori matematici operatori di confronto operatori logici   Operatori matematici in PHP Gli operatori matematici agiscono su uno o più operandi e restituiscono un valore numerico. Questi operatori, dunque, richiamano le operazioni matematiche che rappresentano: il + per l’addizione il - per la sottrazione  il * per la moltiplicazione  il / per la divisione il % per il modulo il ** per l’esponenziale. Vediamoli all'opera su due operandi che, per noi, saranno: $a=5 $b=2 Addizione (somma degli operandi) Usando questo operatore matematico verra' eseguita la somma tra i valori dati al momento dell'inizializzazione delle variabili  (in questo caso 5 + 2 darà come risultato 7) Sottrazione (Differenza fra gli operandi) $a-$b significa che stiamo letteralmente attuando la sottrazione 5-2 e quindi il risultato sarà 3 Moltiplicazione (Prodotto fra operandi) in maniera analoga, $a*$b ci restituirà come risultato il 10 (perchè 5*2=10) Divisione (Quoziente fra operandi) $a/$b significa che stiamo effettivamente dividendo 5 per 2 e ci restituirá un numero in virgola mobile che corrisponde al suo risultato, cioè 2.5 (ricordiamo che in php la virgola mobile sui numeri si indica con un punto). Modulo (Resto degli operandi) Quando parliamo di modulo ci riferiamo al resto degli operandi. Il resto è la quantità "avanzata" dopo aver effettuato la divisione, cioè quella quantità che non è stato possibile dividere affinché il risultato coincidesse con un numero intero. Con $a%$b vogliamo sapere quanto è avanzato dalla divisione di 5 con 2. Il due “entra nel 5” per due volte, e lo scarto ottenuto è 1; il resto della divisione di 5 con 2 é, quindi, 1. E questo sarà esattamente il risultato del nostro modulo. Esponenziale (a elevato alla potenza di b) Quando vogliamo moltiplicare un numero tante volte per se stesso, è best practice non utilizzare l’operatore moltiplicazione, ma l’esponenziale.  Questo perché, ad esempio, 5*5*5*5*5 equivale a scrivere 5 elevato alla potenza di 5. Tornando, quindi, ai nostri due operandi, con $a**$b stiamo elevando 5 alla potenza di 2 (potremmo, anche, dire “cinque alla seconda”). Questo equivale a scrivere 5x5, con risultato pari a 25. Proviamo, ora, ad utilizzare i nostri operatori matematici in PHP. <?php $x = 5; $y = 2; var_dump( $x + $y); var_dump( $x - $y); var_dump( $x * $y); var_dump( $x / $y); var_dump($x % $y); ?> Il nostro output sará: Nb. Abbiamo usato, nell’esempio, una funzione di php (var_dump) che ci consente di vedere in output anche il tipo di dato così da avere una visione piú chiara dei risultati. Non preoccuparti, parleremo delle funzioni di php nel dettaglio nelle prossime guide, cosicché tu possa imparare php in maniera chiara e graduale.   Operatori di confronto in php Gli operatori di confronto agiscono su due operandi e restituiscono un valore booleano (ovvero, un valore che può essere vero o falso: ricordi?). Immaginiamo di avere come operandi un triangolo ed un cubo.  Facciamoci, ora, una serie di domande. Il triangolo è uguale al cubo? Assolutamente falso! Il triangolo è diverso dal cubo? Senza dubbio vero! Il triangolo è piú grande del cubo? Se notiamo esserlo, la risposta sarà, ovviamente, vero. Quelle che possono sembrare ovvietà, applicate al mondo della programmazione informatica, assumono una certa importanza. Usciamo dalla metafora e proviamo a considerare due operandi $c e $d per analizzare nel dettaglio tutti i nostri operatori di confronto. Uguale ( == )  $c == $d restituisce TRUE se $c é uguale a $d, FALSE in caso contrario Identico ( === ) $c === $d restituisce TRUE se $c é uguale a $d, e sono anche dati dello stesso tipo, FALSE altrimenti Estremamente importante è la differenza tra == e ===: == fa un controllo se i due operandi sono uguali in valore. === fa un controllo se i due operandi sono uguali in valore ma anche in tipo di dato. Saltiamo nuovamente nella nostra metafora! Non abbiamo più, però, a che fare con un cubo e un triangolo. Questa volta, i nostri operatori saranno due cubi: uno di pietra e uno di plastica.  Il primo operatore, quindi, restituirà TRUE poiché si tratta effettivamente di due cubi: il loro valore è uguale.  Il secondo operatore restituirà, invece, FALSE perché i due cubi sono composti da materiali diversi: uno è fatto di pietra, l’altro di plastica. Due tipologie diverse. Chiaro adesso? Non identici ( !== ) $c !== $b restituisce TRUE se $c non é uguale in valore a $b, e non sono neppure dello stesso tipo, FALSE in caso contrario. Cominci a capire il meccanismo? Non uguali ( != ) $c != $d restituisce TRUE se $c non é uguale a $d, FALSE altrimenti Esiste anche un’altra sintassi per controllare se due operandi sono non uguali ed è $c <> $d  Minore di ( < ) $c < $d restituisce TRUE se $c é piú piccolo di $d, FALSE altrimenti Maggiore di ( > ) $c > $d restituisce TRUE se $c é piú grande di $d, FALSE altrimenti Minore o uguale ( <= ) $c <= $d restituisce TRUE se $c é piú piccolo o uguale a $d, FALSE altrimenti Maggiore o uguale ( => ) $c >= $d restituisce TRUE se $c é piú grande o uguale a $d, FALSE altrimenti Proviamoli in php: <?php $c = 20; $d = 10; var_dump( $c == $d); var_dump( $c != $d); var_dump( $c <> $d); var_dump( $c < $d); var_dump( $c > $d); var_dump( $c <= $d); var_dump( $c >= $d); ?> Il nostro output sará: Facciamo, ora, degli altri esempi: <?php $a = 10; $b = "10"; var_dump( $a == $b); //true perché in valore i due numeri sono uguali var_dump( $a === $b); //false perché i due numeri sono uguali in valore MA NON IN TIPO var_dump( $a != $b); //false perché in valore i due numeri sono uguali var_dump( $a !== $b); //true perché i due numeri sono uguali in valore MA NON IN TIPO ?> Il nostro output sará: Come puoi notare, nell’ultimo esempio le due variabili sono di tipo differente: una è un numero e una è una stringa.  Potremmo, tuttavia, applicare anche delle operazioni, poiché php riconosce una stringa numerica: analizza, cioè, partendo da sinistra, carattere per carattere e se riconosce un numero, lo userá come numero effettivo; se identifica, peró, immediatamente dopo, un carattere ci ritornerà un errore. Vediamo direttamente degli esempi in php: <?php $a = 10; $b = "10"; echo "PRIMO RISULTATO \n"; echo $a + $b; echo "\n"; $a = 10; $b = "10ciao"; echo "SECONDO RISULTATO \n"; echo $a + $b; echo "\n"; $a = 10; $b = "ciao10"; echo "TERZO RISULTATO \n" echo $a + $b; ?> l’output sarà: Osserviamo. Il primo risultato è la normale somma;  nel secondo PHP ci mostra un avviso, ma in qualche modo riesce comunque a restituirci una somma. Nel terzo, invece, abbiamo proprio un fatal error.    Operatori logici in PHP Prima di definire che cosa sono gli operatori logici e vederli in azione, occorre precisare due concetti molto importanti. Stiamo parlando dei concetti di dato truthy e dato falsy.   Dati truthi in PHP Un dato è definibile truthy quando è quantificabile e contiene un valore non nullo. Alcuni esempi possono essere: Numeri diversi da zero; Stringhe non vuote; Array non vuoti (esempio: [3,’D’,2.3,”Ciao”]); Il valore booleano True.   Dati falsy in PHP Un dato è falsy, invece, quando contiene un valore nullo o non quantificabile. Ad esempio: 0; Stringa vuota; Array vuoto (esempio []); Il valore booleano False. Alcuni esempi in php: <?php var_dump((bool) ""); // false var_dump((bool) " "); //true var_dump((bool) 1); //true var_dump((bool) -2); //true var_dump((bool) "foo"); //true var_dump((bool) 2.35); //true var_dump((bool) [12]); //true, var_dump((bool) []); // false var_dump((bool) "false"); //true ?> Il nostro output: Ciò detto, possiamo tornare ai nostri operatori logici. Gli operatori logici agiscono su due operandi e restituiscono un valore booleano True o False e sono:  AND la cui sintassi è la doppia "e commerciale” &&  OR si indica con doppio “pipe”, chiamato anche “barra verticale” ||   NOT  si indica con il punto esclamativo ! L’operatore AND ritorna true SE E SOLO SE entrambi gli operandi sono valori truthy. Esempio in php: <?php var_dump(true && true); //true var_dump(true && false); //false var_dump(false && true); //false var_dump(false && false); //false ?> Il nostro output: L’operatore OR ritorna true SE ALMENO UNO degli operandi è un valore truthy. Esempio in php: <?php var_dump(true || false); //true var_dump(false || true); //true var_dump(true || true); //true var_dump(false || false); //false ?> Il nostro output L’operatore NOT ritorna il booleano inverso. Per esempio, applicato a un valore truthy ritornerà false e viceversa. Esempio in php: <?php var_dump(!true); //false var_dump(!false); //true ?> Il nostro output:   ATTENZIONE Gli operatori && e || hanno una peculiaritá da non sottovalutare. Consideriamo le regole appena viste, che prevedono che l'AND sia vero SE E SOLO SE entrambi gli operandi sono veri e l'OR sia vero se ALMENO UNO DEI DUE é vero.. Come avviene l’esecuzione della valutazione? Essa avverrà da sinistra verso destra. Capiamo insieme come. Supponiamo di avere i nostri due operatori che, questa volta, saranno due mele. Chiediamoci: sono mele gialle? La risposta sará si se entrambe sono gialle.  Come farà il nostro operatore and a capirlo? Semplice: controllerà se la prima mela è gialla, e poi dovrà controllare se anche la seconda lo è.  Nel caso in cui la prima fosse, ad esempio, verde sarebbe inutile per lui controllare la seconda, che potrebbe a quel punto essere di qualsiasi altro colore: all’operatore non interesserà, poiché la risposta sarà già "le mele non sono entrambe gialle". Il valore ritornato, dunque, sarà false. Una delle due mele é gialla? Se una delle due mele é effettivamente gialla, la risposta sará si. Ma sarà il nostro operatore or a capirlo. Come? Controllerà la prima mela, e, se questa sarà gialla l’operatore non avrà necessità di controllare la seconda: una delle due è del colore che cerca. Se, invece, la prima mela non dovesse essere gialla, l’operatore or dovrebbe, per forza di cose, andare a controllare la seconda. A quel punto la risposta sarà “true” se la seconda mela è del colore che l’operatore cerca, e “false” in caso contrario.  È chiaro, dunque, cosa succede quando utilizziamo l’and (&&) o l’or (||)?  Ribadiamolo: viene valutato il primo dato e, se è possibile capire se la risposta è vera o falsa sin dal primo controllo, il secondo dato non verrà considerato; se, peró, il controllo del primo dato non è sufficiente a darci una risposta, allora verrá valutato e considerato il secondo. Alcuni esempi in php: <?php var_dump(5 && "pippo"); //TRUTHY && TRUTHY var_dump(" " && 0); //TRUTHY && FALSY var_dump(null && true); //FALSY && TRUTHY var_dump([] && ""); //FALSY && FALSY ?> A riga 2 sono stati valutati entrambi i dati A riga 3 sono stati valutati entrambi i dati A riga 4 è stato valutato solo il primo A riga 5 è stato valutato solo il primo Il nostro output Qualche ulteriore esempio in php: <?php var_dump(5 || "pippo"); //TRUTHY && TRUTHY var_dump(true || 0); //TRUTHY && FALSY var_dump("" || [12]); //FALSY && TRUTHY var_dump("" || 0); //FALSY && FALSY ?> A riga 2  è stato valutato solo il primo A riga 3 è stato valutato solo il primo A riga 4 sono stati valutati entrambi i dati A riga 5  sono stati valutati entrambi i dati Il nostro output  

Giunto a questo punto sarai sicuramente già molto entusiasta delle nozioni imparate, e non vedrai l’ora di fare sul serio! Che ne dici? Proseguiamo? Vediamo, in questa guida, che cosa sono le cosiddette strutture di controllo: sequenza, selezione e iterazione. A venire in nostro aiuto per introdurle, è il famosissimo Teorema di Böhm-Jacopini (Corrado Böhm e Giuseppe Jacopini). Il Teorema di Böhm-Jacopini, infatti,  afferma che qualunque algoritmo può essere implementato in fase di programmazione utilizzando tre sole strutture, dette strutture di controllo:  la sequenza la selezione  l' iterazione (o ciclo) da applicare ricorsivamente alla composizione di istruzioni elementari. Analizziamo, ora, le strutture di controllo una per volta. SEQUENZA IN PHP Abbiamo, nel nostro codice, questa situazione: <?php $num1=2; $num2=5; echo $num1+$num2; ?> Da cui risulterá: La sequenza parte dall'alto verso il basso ed esegue gli statement (istruzioni) uno alla volta. In pratica: il primo step assegna il valore 2 alla variabile $num1 il secondo step assegna il valore 5 alla variabile $num2 il terzo step vede il comando echo e mostra la somma delle due variabili Come puoi notare dalla descrizione appena fatta, tutto avviene in sequenza, dall'alto verso il basso.   SELEZIONE (condizione) IN PHP Nella selezione, al verificarsi di una condizione (interna ad un’istruzione) verranno eseguite delle righe di codice. Le istruzioni possono essere: if  else elseif switch IF PHP Quando incontra l’istruzione IF, il programma esegue il codice presente all’interno del suo corpo solo se la condizione è verificata.  <?php $is_student = true; if($is_student == true){ echo "Si sei uno studente!"; } ?> Da cui risulterá: Per sequenza verrá assegnato il valore true alla variabile $is_student, successivamente verrá incontrata l'istruzione if con la condizione al suo interno vera, e, quindi, il codice verrá eseguito. Vediamo lo stesso esempio scritto, però, in modo un pochino diverso: <?php $is_student = true; if($is_student){ echo "Si sei uno studente!"; } ?> Ne risulterá ugualmente: Ti chiedi il perché? Questo avviene perché la variabile $is_student é un valore truthy, quindi possiamo omettere il controllo che sia == true. PHP IF/ELSE Con questo tipo di istruzioni Il programma eseguirà il codice nel corpo dell'if solo se la condizione nelle parentesi è verificata. Altrimenti, eseguirá il codice presente nel corpo dell'else. <?php $is_student = true; if($is_student == true){ echo "Si sei uno studente!"; }else{ echo "Non sei uno studente!"; } ?> Da cui risulterá: Per sequenza, verrà assegnato il valore false alla variabile $is_student, poi verrà incontrata l'istruzione if con la condizione al suo interno che però risulterà falsa (quindi un dato falsy). Dunque, non verrá eseguito il codice all'interno del corpo del'if ma il codice presente nel corpo dell'else.   PHP IF/ELSEIF/ELSE Analogamente a quanto sopra, con queste istruzioni il programma esegue il codice nel corpo dell'if solo se la condizione truthy all'interno delle parentesi é verificata. Se non è così, va ad analizzare la condizione nelle parentesi dell’ elseif; se questa è verificata la eseguirà, altrimenti eseguirá il codice presente nel corpo dell'else. <?php $color = 'red'; if($color == 'red'){ echo "Il colore é rosso!"; }elseif($color == 'blue'){ echo "Il colore é blue!"; }else{ echo "Il colore non é ne rosso ne blu!"; } ?> Da cui risulterá: Per sequenza verrà assegnato il valore 'red' alla variabile $color, dopodichè verrà incontrata l'istruzione if con la condizione al suo interno che é vera, quindi truthy. Quindi, grazie al php echo, il programma stamperá in console che il colore è rosso.  Se il controllo nel primo if fosse stato falsy la sequenza sarebbe andata avanti incontrando la successiva istruzione dell’ elsif e, quindi, controllando se la condizione fosse verificata, in caso di truthy avrebbe stampato a terminale “il colore è blu”. Se nessuna delle due condizioni nell'if e nell'else-if si fosse verificata sarebbe stato eseguito l'ultimo php echo che ci avrebbe stampato a terminale “il colore non è ne rosso ne blue.” Semplicissimo, vero? PHP SWITCH E se il numero degli elseif aumentasse? Niente paura! Per fortuna, non dovremmo scriverli tutti creando, così, codice poco chiaro e non leggibile: useremmo, invece, lo switch case. Lo switch non fa altro che valutare il valore di una variabile e scegliere un percorso da seguire tenendo conto di quest’ultimo. Se non troverà una corrispondenza, seguirà un percorso definito di default (predefinito). Possiamo immaginare il comportamento dello switch come se fosse una stanza con tre porte colorate. Una gialla, una verde ed una blu. All’entrata ci consegnano un bigliettino corrispondente ad uno di questi tre colori e noi, quindi, possiamo aprire solo quella con il colore corrispondente. Il bigliettino è la variabile da valutare, mentre le porte sono le parti di codice da eseguire. Vediamo un esempio: <?php $color="yellow"; //Nelle parentesi tonde mettiamo la variabile che vogliamo valutare switch($color){ case $color == "green": echo "Sei entrato nella porta verde!"; break; case $color == "blue": echo "Sei entrato nella porta blu!"; break; case $color == "yellow": echo "Sei entrato nella porta gialla!"; break; default: // gestisce tutte le altre casistiche che non ho pensato echo "Non ci sono porte del colore scelto!"; break; } //Output //Sei entrato nella porta gialla! ?> Come notiamo dall’esempio, tutti i “case” ed il default sostituiscono tutti gli if/else/elseif. Il break blocca il codice, che - ricordiamoci - segue una sequenza di esecuzione dall’alto verso il basso, ed il default verrà eseguito se $color non corrisponde a nessuno dei valori elencati nei case. ITERAZIONE IN PHP Le iterazioni ( o cicli ) sono blocchi di codice che si ripetono finché una determinata condizione da truthy non diventa falsy, ma anche per ogni elemento di una struttura dati complessa ( sempre, peró, finché la condizione risulti essere vera (truthy). I cicli sono: for foreach while do-while Analizziamoli uno per volta. Ciclo FOR PHP Un ciclo for ripete il codice racchiuso all'interno del suo corpo finché una particolare condizione non diventerá falsa (falsy). Questa condizione sará proprio un controllo sul numero di volte in cui avrá effettuato il ciclo. É costituito da: un punto d'entrata della logica del ciclo che corrisponderá ad un indice inizializzato a 0 (ovviamente a seconda dell’utilizzo puó avere anche valori diversi da zero) la condizione di controllo del numero di cicli effettuati l'incremento/decremento dell'indice Vediamo un esempio di ciclo for: <?php for ($i=0; $i < 5; $i++) { echo $i."\n"; } ?> Da cui risulterá: Come puoi notare, questo ciclo non fará altro che mostrarci tutti i numeri da 0 a 4, poiché, nell'ultimo ciclo, effettuerá un controllo sulla condizione con l'indice pari a 5: tuttavia, 5 non é minore di 5 e, quindi, il nostro ciclo si fermerá mostrandoci il valore di $i pari a 4.   Ciclo FOREACH PHP Un ciclo foreach viene utilizzato per selezionare e manipolare tutti gli elementi di un array ma anche di una collection (collezione di dati). E' composto da due parti principali: L'array o la collection da ciclare una variabile d'appoggio (immaginala come un contenitore all'interno del quale verrá inserito il dato appena preso dalla struttura dati) La differenza fondamentale fra un ciclo for e un foreach è che il ciclo  si fermerà quando tutta la struttura dati sarà finita. Non possiamo controllare i cicli, come, invece, abbiamo fatto con la condizione del ciclo for. <?php $elements=['ciao','sono','il','dato']; foreach ($elements as $element) { echo $element."\n"; } ?> Da cui risulterá: Come vediamo, il programma ci stamperá in output ogni singolo dato dell'array. Possiamo utilizzare il php echo, in questo caso, perché ogni singolo dato è un dato semplice. Se stessimo, invece, catturando dati complessi dall’array avremmo dovuto utilizzare la php print_r(). Ciclo WHILE PHP Un ciclo while esegue la porzione di codice al suo interno solo e soltanto se alla prima valutazione della sua condizione, questa sarà truthy. Tutte le successive esecuzioni del codice avverranno solo e soltanto se la condizione risulterà ancora truthy. <?php $num=0; while($num < 5){ echo $num."\n"; $num++; } ?> Da cui risulterá: Osserva: eseguendo il codice dall’alto verso il basso (sequenza) cosa succede? Il programma inizializza una variabile chiamata $num a zero, incontra la dichiarazione del ciclo while e ne valuta la condizione. Effettivamente, 0 é minore di 5 e quindi la sua condizione sarà truthy; di conseguenza, entrerá nel corpo del ciclo while ed eseguirá il php echo, mostrandoci il valore di $num che risulterá essere 0.  Incontrerá, poi, lo statement di incremento della variabile $num, per poi tornare a controllare la condizione. Ora $num é 1; 1 è minore di 5 quindi la sua condizione sarà ancora truthy e la porzione di codice si ripeterá finché $num non diventerá 5, che non sarà minore di 5 quindi il ciclo si fermerá. Ciclo DO-WHILE PHP Il ciclo do-while, a differenza del ciclo while, esegue la porzione di codice al suo interno almeno una volta e senza valutare la condizione prima di poter eseguire il codice al suo interno. Per le successive esecuzioni del codice verrá valutata la condizione che dovrá essere truthy e ripeterá il codice all'interno del corpo del do. <?php $num=0; do{ echo $num."\n"; $num++; }while($num < 5); ?> Da cui risulterá: Come sopra: eseguendo il codice dall’alto verso il basso (sequenza) vediamo cosa succede. Il programma inizializza una variabile chiamata $num a zero, incontra la dichiarazione del ciclo do-while ed entra nel corpo del do eseguendo il codice. Esegue, quindi, il php echo, mostrandoci il valore di $num (0 in questo passaggio); incontra, poi, l’incremento della variabile e aggiunge 1 a $num. Adesso valuta la condizione, 1 è effettivamente minore di 5 quindi la condizione sarà verificata e la porzione di codice si ripeterá finché $num non diventerà 5. Infine verifica che 5 non é minore di 5 e, quindi, blocca il ciclo.

Lo step successivo per imparare php e diventare sviluppatori php prevede l’acquisizione di una nozione fondamentale. Vediamo quale. Partiamo col dire che uno degli obiettivi primari nella scrittura del codice è scrivere quanto meno codice possibile e rimuovere ogni tipo di duplicazione, in modo tale da farlo essere chiaro, leggibile, ma, soprattutto, manutenibile al fine di spendere meno tempo possibile nella risoluzione dei problemi ma anche per facilitare eventuali aggiunte di codice successive.  A tale scopo, ci avvaliamo delle funzioni. Le funzioni ci aiutano, infatti, nel rispettare un concetto definito come DRY (Don't repeat yourself): perché ripetere del codice giá scritto da un'altra parte? Sarebbe inutile e controproducente! Useremo, invece, per l’appunto, le funzioni.  Le funzioni sono proprio una delle pratiche migliori (best practice) da seguire nella creazione di un codice definito modulare, e sono strettamente collegate a 3 concetti molto significativi: estrarre (extract), incapsulare (incapsulate) e astrarre (abstract). Questi concetti ci dicono, rispettivamente, che possiamo: estrarre una porzione di codice (quindi prendere una parte di codice) incapsularla all'interno di una funzione (cioè inserirla all'interno di un contenitore) astrarre la funzione in modo tale che non risolva un solo problema specifico, ma sia generalizzata il piú possibile, affinché la sequenza di passi incapsulati possa essere riutilizzata in diverse parti del nostro codice. Ti abbiamo incuriosito abbastanza? Pronto a saperne di più sull' universo delle funzioni? 

  Prima di vedere come definire una funzione e come usarla, è importante dire che le funzioni si differenziano in due grandi famiglie: Bult-in function: delle funzioni proprie del linguaggio php, che noi non possiamo modificare, ma utilizzarne "i benefici" all'interno del nostro codice User function: delle funzioni create interamente dallo sviluppatore web Ci occuperemo, in questa guida, delle User function. User function in PHP Una User function è composta da quattro parti: la keyword function il nome della funzione (inventato, ma quanto più descrittivo possibile del compito della funzione stessa), che utilizzeremo nel nostro codice per richiamarla ed utilizzarla le parentesi tonde, che definiscono un punto di entrata per quei valori che definiamo “esterni” alla funzione, ovvero i parametri  il corpo della funzione dove istruiremo (scriveremo) la logica (il codice) delimitato da parentesi graffe Vediamo, ora, come si definisce una funzione: <?php function helloWorld(){} ?> Come vedi, nell’ esempio soprastante abbiamo effettivamente scritto una funzione in tutto e per tutto. Questa funzione, però, non farà praticamente nulla, poiché non abbiamo istruito la logica. Come possiamo farlo? <?php function helloWorld(){ echo "Ciao Mondo! \n"; } ?> La logica, come puoi notare, è la parte di codice compresa tra le parentesi graffe; in questo caso, la nostra funzione “stamperà in console” e renderizzerà a schermo le parole “Ciao Mondo!”. Cosa intendiamo con “stampare in console”? Per spiegartelo facciamo un piccolo focus su php echo, reggiti forte!   PHP echo Iniziamo il nostro piccolo approfondimento con una definizione presa direttamente dalla documentazione php ufficiale: "echo non è una funzione ma un costrutto del linguaggio. I suoi argomenti sono un elenco di espressioni che seguono la parola chiave echo, separate da virgole e non delimitate da parentesi." In pratica, “php echo” prende tutto ciò che segue la keyword echo e lo trasforma in una stringa, mostrandocelo in output, vale a dire “mostrandocelo sullo schermo”, oppure nella console (ovvero il terminale). Adesso, quindi, abbiamo una funzione che effettivamente compie un’azione. In realtà, però, manca ancora qualcosa: perché diamo un nome al blocco di codice che compie un'azione specifica? Lo facciamo per poterla richiamare in diversi punti all'interno del nostro codice.Ricordiamoci, quindi, che una funzione, se non richiamata, non viene "attivata" ed effettivamente non farà nulla. Come fare, allora, per richiamare la nostra funzione? Semplice! Attraverso il suo nome seguito dalle parentesi tonde  <?php function helloWorld(){ echo "Ciao Mondo! \n"; } helloWorld(); ?> In output ci dará: Esattamente quello che volevamo e ci aspettavamo. Ma se volessimo, invece, una funzione che ci mostri in output una prima parte “standard” e una seconda parte dinamica? Vediamo un esempio. Vogliamo che la nostra funzione ci mostri in output frasi come: "Hai scelto il colore rosso!" "Hai scelto il colore blu!" "Hai scelto il colore giallo!" "Hai scelto il colore verde!" "Hai scelto il colore arancione!" Come dicevamo, la prima parte rimane uguale e la parte finale cambia di volta in volta. Vediamo come fare. Innanzitutto, una caratteristica importante delle funzioni è che possiamo richiamarle piú volte ed avere in output il risultato delle istruzioni al loro interno. Cosa vuol dire? Se richiamassimo piú volte la funzione "helloWorld" il risultato sarebbe il seguente: <?php function helloWorld(){ echo "Ciao Mondo! \n"; } helloWorld(); helloWorld(); helloWorld(); helloWorld(); helloWorld(); ?> In output ci darebbe: Questo avverrebbe perché, al suo interno, la funzione non fa altro che mandare in output il risultato della nostra istruzione “php echo” (alla quale abbiamo aggiunto un “\n” per poter far andare a capo ad ogni nuova stampa). Per poter avere un risultato "personalizzato", come ad esempio la stampa di una stessa frase "Hai scelto il colore" e poi la parte del colore dinamica, dobbiamo introdurre il significato di parametro formale e parametro reale.  

Ricordi cosa abbiamo detto quando abbiamo introdotto le funzioni? Le parentesi tonde sono "un punto di entrata per poter far accedere all’interno della funzione valori esterni". All’interno delle parentesi tonde inseriremo un cosiddetto parametro formale, che verrà, in seguito, sostituito dal parametro reale (che nel nostro caso, per poter raggiungere l’obiettivo che ci siamo prefissati nel precedente articolo della nostra guida su come imparare php, è il colore). Il parametro formale dice alla funzione che, in quel punto, arriverá qualcosa dall'esterno e che poi assumerá un valore effettivo (reale). Il parametro reale è il valore effettivo che diamo alla funzione. <?php function whatColor($color){ echo "Hai scelto il colore $color! \n"; } ?> Nell’esempio, il $color nelle parentesi tonde è il parametro formale. Non ha un valore effettivo, è un contenitore vuoto che verrà riempito quando richiameremo la funzione per attivarla. <?php function whatColor($color){ echo "Hai scelto il colore $color! \n"; } whatColor('rosso'); whatColor('blu'); whatColor('giallo'); whatColor('verde'); whatColor('arancione'); ?> 'rosso', 'blu', 'giallo', 'verde', 'arancione' sono i parametri reali che diamo alla funzione nel momento in cui la richiamiamo, inserendolo tra le tonde che nell’esempio precedente, erano vuote. Il parametro formale diventa il parametro reale In output avremo, di conseguenza: Il php echo all'interno della funzione é diventato del tutto dinamico e la nostra funzione "whatColor($color)" è generale, ASTRATTA.. Tutto chiaro? Benissimo! Abbiamo, quindi, assodato le nozioni di parametro formale e parametro reale. Ciò che abbiamo tralasciato, però, è una caratteristica importante dei parametri reali: il modo in cui la loro posizione all’interno delle parentesi tonde influisce sul risultato. Vediamo un esempio <?php function presentati($nome, $cognome){ echo "Ciao il mio nome è $nome ed il mio cognome é $cognome "; } presentati('Giuseppe', 'Verdi'); //In output avremo: //Ciao il mio nome è Giuseppe ed il mio cognome é Verdi ?> Se invertissimo i parametri reali nel richiamare la nostra funzione, il risultato sarebbe decisamente diverso, non credi? <?php function presentati($nome, $cognome){ echo "Ciao il mio nome è $nome ed il mio cognome é $cognome "; } presentati('Verdi', 'Giuseppe'); //In output avremo: //Ciao il mio nome è Verdi ed il mio cognome é Giuseppe ?> Si tratta di un esempio banale, ma ci fa capire bene l’importanza di assegnare la giusta posizione ai nostri parametri reali.  

Negli articoli precedenti di questa guida, ci siamo occupati delle cosiddette user function, ovvero quelle funzioni create manualmente dallo sviluppatore web. Riteniamo opportuno, tuttavia, al fine di imparare php nel migliore dei modi, esplorare anche l’universo delle funzioni di built-in, ovvero, come già detto,  delle funzioni natie del linguaggio php. Per facilitarne l’apprendimento suddivideremo le funzioni di built-in in funzioni per lavorare con le stringhe, funzioni per lavorare con i numeri e funzioni per lavorare con gli array. Naturalmente - gli sviluppatori php lo sanno bene - le funzioni di built-in sono svariate e assai numerose. In questa sede, analizzeremo le principali. Che cos'è una stringa in PHP Se ricordi una delle lezioni php precedenti, in cui avevamo analizzato i tipi di dati in php, saprai senz’altro cos’è una stringa. Per comodità andiamo velocemente a ribadirlo: una stringa è una sequenza di lettere, numeri, caratteri speciali e valori aritmetici o una loro combinazione. Il modo più semplice per creare una stringa è racchiudere il contenuto della stringa (cioè i caratteri della stringa) tra virgolette singole ('), come in questo caso: $my_string = 'Hello World'; È possibile utilizzare anche le virgolette doppie ("). Tuttavia, le virgolette singole e quelle doppie funzionano in modo diverso. Le stringhe racchiuse tra virgolette singole sono trattate sempre come una stringa, mentre le stringhe delimitate da virgolette doppie permettono l’interpolazione delle variabili, ovvero, le variabili vengono sostituite con le rappresentazioni in stringa dei loro valori e interpretano in modo speciale alcune sequenze di escape. <?php $name = “Mario”; $greet = “Piacere di conoscerti $name” echo $greet // Piacere di conoscerti Mario ?> Le sostituzioni delle sequenze di escape sono: \n o \r crea una nuova linea \t è sostituito dal carattere di tab o tabulazione \$ è sostituito dal segno del dollaro ($) \" è sostituito da un singolo doppio apice (") \\ è sostituito da una singola barra rovesciata (\). Ecco un esempio per chiarire le differenze tra stringhe con virgolette singole e doppie: <?php $str = 'World'; echo "Hello, $str!"; // Mostra: Hello World! echo 'Hello, $str!'; // Mostra: Hello, $my_str! echo 'Hello\tWorld!'; // Mostra: Hello\tWorld! echo "Hello\tWorld!"; // Mostra: Hello World! echo 'I\'ll be back'; // Mostra: I'll be back ?> Manipolazione delle stringhe in PHP PHP fornisce molte funzioni integrate per la manipolazione delle stringhe, come il calcolo della lunghezza di una stringa, la ricerca di sottostringhe o caratteri, la sostituzione di parte di una stringa con caratteri diversi, la scomposizione di una stringa e molte altre. Andiamo ad analizzarne alcune.  Calcolo della lunghezza di una stringa: php strlen() La funzione strlen() serve a calcolare il numero di caratteri all'interno di una stringa. Include anche gli spazi vuoti all'interno della stringa. <?php $str = 'PHP è bellissimo'; // Output: 17 echo strlen($str); ?> Attenzione, però! In realtà, se andassimo effettivamente a contare i caratteri in questione scopriremmo che sono 16 e non 17. Com'è possibile, allora, che php ci dica che la stringa è formata da 17 caratteri? Questo accade perché la funzione “strlen” non conta letteralmente i caratteri, ma i byte che la stringa occupa in memoria e nel nostro caso specifico abbiamo un carattere speciale ovvero “è” che occupa 2 byte. Per risolvere questo inconveniente molte funzioni di php hanno una controparte che inizia con mb_* che opera sulle stringe multibyte. <?php $str = 'PHP è bellissimo'; // Output: 17 echo strlen($str); // Output: 16 echo mb_strlen($str); ?> Conteggio del numero di parole in una stringa: php  str_word_count()  La funzione str_word_count() conta il numero di parole in una stringa. <?php $str = 'come contare le parole in una stringa PHP'; // Output: 8 echo str_word_count($str); ?> Inversione di una stringa: php strrev() La funzione strrev() inverte una stringa. <?php $str = 'invertire stringa PHP'; // Output: ‘PHP agnirst eritrevni’ echo strrev($str); ?> Sostituzione di testo all'interno di stringhe: php str_replace() La funzione str_replace() sostituisce tutte le occorrenze del testo cercato all'interno della stringa di destinazione. <?php $str = 'lezioni PHP'; // Output: ‘corso PHP’ echo str_replace('lezioni', 'corso', $str); ?> Estrarre parte di una stringa: php substr() La funzione substr() consente di estrarre una porzione di stringa, partendo da una specifica posizione. <?php $str = "io amo PHP"; echo substr($str, 3, 3); // amo echo substr($str, 7, 3); // PHP echo substr($str, -3); // PHP ?> Cercare una parola all'interno di una stringa: php strpos() Capita spesso di voler verificare se una stringa contiene una specifica parola. In questi casi PHP mette a disposizione la funzione strpos() che restituisce la posizione della prima occorrenza della parola cercata, altrimenti false. <?php $str = "come imparare PHP"; // Output : 7 echo strpos($str , ‘PHP’); // Output : false echo strpos($str , ‘Javascript’); ?> Trasformare una stringa in un Array: php explode() Possiamo suddividere una stringa in un array dividendo la stringa in base a un carattere passato alla funzione php explode <?php $str = "Trasforma stringa in array PHP"; $array= explode(" ", $str); print_r($parts); ?> /* Output Array ( [0] => "trasforma" [1] => "stringa" [2] => "in" [3] => “array” [4] => “PHP” ) */ Converti i caratteri in maiuscolo o minuscolo: php strtoupper() e php strtolower() Le funzioni strtoupper() e strtolower() convertono i caratteri di una determinata stringa rispettivamente in maiuscolo e minuscolo. <?php $str = "convertire i caratteri in maiuscolo o minuscolo"; echo strtolower($str); // convertire i caratteri in maiuscolo o minuscolo echo strtoupper($str); // CONVERTIRE I CARATTERI IN MAIUSCOLO O MINUSCOLO ?> Convertire stringhe in date in php: strings php to date() La funzione date() in PHP è un'importante funzione di built-in che consente di ottenere la data corrente o formattare una data specifica secondo il formato desiderato. È ampiamente utilizzata per gestire le operazioni relative alle date all'interno delle applicazioni PHP. La sintassi di base della funzione `date()` è la seguente: string date(string $formato [, int $timestamp = time() ]) - Il parametro `$formato` specifica il formato desiderato per la data. Questo formato è una stringa che può contenere caratteri speciali o simboli di formattazione, come "d" per il giorno, "m" per il mese e "Y" per l'anno. - Il parametro opzionale `$timestamp` rappresenta il valore temporale su cui eseguire la formattazione. Se omesso, viene utilizzato il timestamp corrente, ottenuto dalla funzione `time()`. Ecco alcuni esempi di utilizzo della funzione date(): // Ottenere la data corrente nel formato "d/m/Y" $dataCorrente = date("d/m/Y"); echo $dataCorrente; // Output: 06/06/2023 // Ottenere l'ora corrente nel formato "H:i:s" $oraCorrente = date("H:i:s"); echo $oraCorrente; // Output: 10:30:45 La funzione `date()` è estremamente flessibile e permette di specificare una vasta gamma di formati per ottenere la rappresentazione desiderata della data. Per quanto riguarda la conversione di una stringa in una data, PHP offre la funzione `strtotime()`, che converte una stringa in un timestamp UNIX. Questo timestamp può quindi essere utilizzato con la funzione `date()` per formattare la data come desiderato. Ad esempio: $stringaData = "2023-06-06"; $timestamp = strtotime($stringaData); $dataFormattata = date("d/m/Y", $timestamp); echo $dataFormattata; // Output: 06/06/2023 In questo esempio, la stringa "2023-06-06" viene convertita in un timestamp utilizzando la funzione `strtotime()`. Successivamente, il timestamp viene passato alla funzione `date()` per ottenere la rappresentazione formattata della data nel formato "d/m/Y". Utilizzando la combinazione delle funzioni `strtotime()` e `date()`, è possibile convertire facilmente una stringa in una data e formattarla secondo le esigenze specifiche del progetto. Ciò offre un'ampia flessibilità nella gestione delle operazioni relative alle date all'interno delle applicazioni PHP.

Che cos'è un numero in PHP Analogamente a quanto detto per le stringhe, rispolveriamo velocemente il concetto di dato numerico in PHP: i numeri in php fanno parte dei cosiddetti dati semplici e si dividono in “integer”, ovvero i numeri interi, e “float” ovvero i numeri a virgola mobile.  Il linguaggio di programmazione php mette a disposizione numerose funzioni per lavorare con i tipi di dati numerici. Vediamo le principali. Trovare il numero massimo e il numero minimo in PHP Il linguaggio PHP fornisce 2 funzioni estremamente utili per estrapolare il valore massimo e il valore minimo di un php array. Proviamo a capire in che modo avere queste informazioni possa risultare così importante. Pensiamo, ad esempio, di star navigando su un e-commerce. Quello che vogliamo, immediatamente, fare è avvalerci di un sistema di filtraggio dei prodotti. Sarebbe fantastico poter trovare subito il meno caro, no? O magari, dovendo fare un regalo, ci piacerebbe capire qual è il prodotto più acquistato per valutarne, ad esempio, le recensioni. Cominci ad entrare nel meccanismo? In tal senso, le funzioni min() e max() di PHP sono una vera manna dal cielo. Vediamone il funzionamento. Immaginiamo di avere un php array di numeri di ordine casuale. $array_esempio = [4, 65, 23, 987, 12, 2]; Per calcolare il valore minimo utilizzeremo, sul nostro array d’esempio, la funzione di built-in php min() $valore_minimo = min($array_esempio); // quello che otterremo sarà 2 In maniera analoga, utilizzeremo per ottenere il valore massimo dell’array, la funzione di php max() $valore_massimo = max($array_esempio); quello che otterremo sarà 987 Cosa succederebbe, però, se dovessimo aver a che fare con dei numeri a virgola mobile? Lo vediamo subito, scoprendo le funzioni di built-in successive. Arrotondare un numero a virgola mobile (float) in PHP PHP dispone di 3 funzioni di built-in per arrotondare i numeri decimali: floor(): permette di arrotondare un numero decimale per difetto; otterremo, quindi, il primo numero intero inferiore disponibile; ceil(): consente, al contrario, di arrotondare un numero float per eccesso: andremo, dunque, al numero intero superiore; round(): arrotonda un numero decimale tenendo conto del grado di precisione che gli indicheremo, ovvero l’indice di quanti numeri sono presenti dopo la virgola (ricordiamo che, ad esempio, 1,5 ha precisione uno, 27,52 ha precisione 2, 6,123 ha precisione 3 e via discorrendo). Vediamo subito un esempio concreto utilizzando il codice. echo floor (1.5) ; // otterrà come risultato 1 echo ceil (1.7) ; // otterrà come risultato 2 echo round (3.4534, 2) ; // otterrà come risultato 3.45 Calcolare un numero random in PHP L’ultima funzione matematica di built-in di php della nostra lista è quella che serve per calcolare un numero randomico in php. Ti stupirai di quante volte potrà tornarti utile questa funzione! La funzione in questione è rand() ed utilizzarla è semplicissimo. echo rand(); // otterremo un numero casuale, ad esempio 456 Nb. ricordiamo, per chi se lo fosse perso, a cosa serve il php echo: php echo agisce su tutto quello che segue, appunto, la keyword “echo” e lo converte in una stringa, mostrandolo in output e permettendoci di “vederlo a schermo” Pronto a scoprire le altre funzioni di built-in nelle prossime lezioni php? 

L’ultima tappa del nostro viaggio alla scoperta delle funzioni di built-in di php è inerente a tutte quelle funzioni che riguardano l’ordinamento, la gestione e, più in generale, le operazioni con i php array. Ancora una volta precisiamo che in questa guida non troverai tutte le funzioni php esistenti per lavorare con gli array, bensì quelle più utili e che, più probabilmente, potrà capitarti di dover utilizzare in un progetto reale. Ricordiamo che, nel nostro percorso per imparare PHP, abbiamo già visto come ciclare gli array nella guida inerente ai concetti di sequenza, selezione e iterazione. Tenendo presente ciò, vediamo un po ' di funzioni di built-in che possono tornarci utili. Contare gli elementi di un array: php array count() Nel tuo percorso come sviluppatore web in php potrai trovarti davanti alla necessità di sapere quanti elementi sono contenuti in un php array. Nulla di più semplice! La funzione di built-in adatta a questo scopo è count() Vediamone un’applicazione. Supponiamo di avere un array che contenga gli iscritti ad un corso php online. $iscritti = [ ‘Valerio’ , ‘Paola’ , ‘Alessandro’ , ‘Claudia’ , ‘Giada’ , ‘Davide’ , ‘Marco’ , ‘Leo’ ]; echo “il numero di iscritti al corso php online è " . count($iscritti); Avvalendoci del nostro caro php echo, ciò che otterremo stampato a schermo, sarà “il numero di iscritti al corso php online è 8.” Sapremo quindi, che 8 persone sono interessate ad imparare php!  Estrarre parte di un array: php array_slice() Immaginiamo, adesso, di voler considerare, della nostra lista di iscritti al corso php online, solo determinate persone: Davide, Marco e Leo, infatti, sono stati fortunati ed hanno diritto ad una scontistica! Come facciamo, però, a suggerire a PHP di prendere in analisi soltanto loro 3? La funzione che ci permette di estrarre solo una porzione del nostro array è array_slice(). Questa funzione, accetta 3 parametri: array di partenza l’elemento a partire dal quale inizierà l’estrazione che viene definito offset  il numero di elementi da estrapolare partendo dall’ elemento di offset, vale a dire la lunghezza della “fetta” di array che ci interessa. Proviamo a capire meglio utilizzando l’esempio precedente. $iscritti = [ ‘Valerio’ , ‘Paola’ , ‘Alessandro’ , ‘Claudia’ , ‘Giada’ , ‘Davide’ , ‘Marco’ , ‘Leo’ ]; $output = array_slice($iscritti, 4, 3); print_r ($output); In questo avremmo detto a PHP di restituire come output Davide, Marco e Leo, vale a dire gli ultimi 3 nomi del nostro array di partenza. Ricorda! Nei php array si inizia a contare dallo 0. Il primo elemento sarà in posizione 0.  Ecco perchè, nell’esempio di cui sopra, l’ elemento di offset indicato è 4 : php inizierà a contare, dunque, da ‘Giada’ in poi. Verificare il contenuto di un array: php in_array() Bene! Ora che abbiamo la nostra lista degli iscritti al corso php online, sappiamo quanti sono e sappiamo perfino quali di loro hanno diritto alla scontistica, pensiamo di poter fare sonni tranquilli e mostrar loro come e perchè imparare php. Attenzione! C’è stato un piccolo problema di comunicazione interna e ci viene richiesto se effettivamente una studentessa di nome Marta è presente nella lista. Come fare a verificare se il nome di Marta è presente nell’array degli iscritti? Niente panico! La funzione adatta in questo caso è in_array() che ci consente, appunto, di verificare il contenuto di un array. Questa funzione accetta due parametri: il valore che stiamo cercando e l’array in cui vogliamo cercarlo. Vediamolo nel codice. $iscritti = [ ‘Valerio’ , ‘Paola’ , ‘Alessandro’ , ‘Claudia’ , ‘Giada’ , ‘Davide’ , ‘Marco’ , ‘Leo’ ]; if (in_array( ‘Marta’ , $iscritti)) { echo “Marta fa parte degli iscritti al corso php online”; } else { echo “Marta non è tra gli iscritti del corso php online”; } Otterremo, quindi, come output che Marta non è tra gli iscritti al corso e potremo comunicarlo a chi di dovere! Ordinamento degli array : php array sort() Un’ altra tipologia di funzioni di built-in assai utili, è quella che consente di ordinare gli array. Ci sono diverse funzioni che php mette a disposizione per farlo. Ne vedremo alcuni, rispettivamente inerenti agli array semplici e a quelli associativi (gli array chiave-valore)  Ordinamento di array semplici L’ ordinamento di array numerici può essere gestito in maniera crescente o decrescente; a seconda di questo fattore le funzioni di built-in da utilizzare saranno: sort() consente di ordinare gli array numerici in ordine crescente, dal più piccolo al più grande; rsort() è l’esatto inverso della funzione precedente: ordina, dunque, gli array numerici in ordine decrescente; Ordinamento di array associativi (chiave-valore) L’ ordinamento di array associativi può essere gestito in maniera crescente o decrescente, e anche alla volontà di gestirli in base al valore o in base alla chiave. Nel primo caso (in base al valore) le funzioni cui fare riferimento saranno: asort() per l’ordine crescente; arsort() per l’ordine decrescente; Nel caso in cui, invece, volessimo procedere all’ordinamento di array associativi in base alla chiave, le funzioni utili saranno: ksort() per l’ordine crescente; krsort() per l’ordine decrescente; Unire gli array: php array_merge() Supponiamo, ora, di avere più di un corso php online. Alla nostra lista di iscritti, si aggiungeranno altre liste similari.  Avremo, dunque, una situazione in cui al nostro array $iscritti andranno ad aggiungersi altri array, quali ad esempio $iscritti2, $iscritti3, e così via. E se ti dicessimo, che è possibile, ad esempio, avere un unico grande array con tutti gli iscritti alle corsi php del 2022? A venire in nostro aiuto, in questo caso, è la funzione array_merge(), che ci consente di unire due o più array. Come funziona? Gli elementi di un array vengono aggiunti in coda a quelli dell’array precedente, e, in caso di valori uguali, l’ultimo sovrascriverà gli altri. Vediamo un esempio. (Al fine di non dilungarci troppo, perdendo il focus sull’ effettivo scopo dell’esempio, faremo finta che l’ array $iscritti contenga solo 3 nomi)  $iscritti = [ ‘Valerio’ , ‘Paola’ , ‘Alessandro’ ]; $iscritti2 = [ ‘Miriam’ , ‘Giulia’ ]; $iscritti3 = [ ‘Nina’ , ‘Ottavio’ ]; $iscritti_totali = array_merge($iscritti, $iscritti2, $iscritti3); print_r($iscritti_totali); Cosa ci restituirà php?  Array ( [0] => Valerio [1] => Paola [2] => Alessandro [3] => Miriam [4] => Giulia [5] => Nina [6] => Ottavio ) Estrapolare chiavi o valori da un array associativo: array_keys() e array_values() Le ultime due funzioni di built-in php che analizziamo, sono quelle utili ad estrarre chiavi o valori da un array associativo. Le funzioni da considerare a questo scopo sono due: array_keys() array_values() Vediamone un esempio pratico, con un array associativo contenente i nostri docenti e le materie che insegnano : <?php $teachers = [ 'Davide' => ['PHP', 'Laravel', 'Python'], 'Marco' => ['HTML', 'CSS', 'Javascript', 'Vue'], 'Roberto' => ['PHP', 'Laravel', 'Flutter'], ]; print_r(array_keys($teachers)); print_r(array_values($teachers)); Array ( [0] => Davide [1] => Marco [2] => Roberto ) Array ( [0] => Array ( [0] => PHP [1] => Laravel [2] => Python ) [1] => Array ( [0] => HTML [1] => CSS [2] => Javascript [3] => Vue ) [3] => Array ( [0] => PHP [1] => Laravel [2] => Flutter ) )    

Negli esempi precedenti abbiamo passato alle funzioni delle variabili, che ricordiamo essere delle locazioni di memoria che contengono dei dati. Se provassimo a modificare il contenuto di una variabile dichiarata esternamente utilizzando una funzione, cosa succederebbe? Vediamolo. <?php $num=7; function changeValue($number){ echo ++$number."\n"; } echo $num."\n";//Prima echo changeValue($num); echo $num."\n";//Seconda echo //In output avremo: //7 //8 //7 ?> Come possiamo notare dal risultato, nel momento in cui, esternamente alla funzione, abbiamo chiesto al comando php echo (Seconda echo) di mostrarci cosa c'è nella variabile $num dopo la function, il risultato è stato identico a quello che ci ha mostrato l'echo prima della chiamata della funzione (Prima echo). Questo è successo perché, in questo caso, richiamando la funzione, le abbiamo passato delle variabili per valore (vale a dire una copia). Esistono quindi due diverse modalità di passaggio dei parametri a una funzione "per valore e per riferimento" Per valore: stiamo passando e manipolando una copia della variabile presente nella locazione di memoria Per riferimento: stiamo passando proprio il contenuto della locazione di memoria senza farne prima una copia Il passaggio per valore a codice avviene tramite un "&" posta vicino al parametro formale della funzione <?php $num=7; function changeValue(&$number){ echo ++$number."\n";//Incrementa il valore di $number di uno } echo $num."\n";//Prima echo changeValue($num); echo $num."\n";//Seconda echo //In output avremo: //7 //8 //8 ?> Adesso il php echo immediatamente sotto la chiamata della funzione (Seconda echo) ci mostra un risultato diverso rispetto all'echo prima della chiamata della funzione (Prima echo) perché la funzione ha modificato l'interno della locazione di memoria a differenza della funzione che riceve una copia del contenuto della variabile.

Lungo il tuo percorso per imparare PHP, potresti doverti trovare a gestire un caso particolare. Supponiamo di voler dichiarare una funzione che possa ricevere un numero indefinito di parametri. Questo tipo di funzione è detta funzione dinamica. Come potremmo fare? Potremmo utilizzare lo splat operator.  Grazie a questo operatore, una funzione può ricevere un numero indefinito di parametri e gestirli con un php array. Lo splat operator si indica ponendo all'interno delle parentesi tonde della funzione  "..." ed il nome del  parametro formale. <?php function multiNumbers(...$numbers){ print_r($numbers); } multiNumbers(3,56,78,6,13,7,89,100,95); ?> In output vedremo Osserva l’esempio: cosa è successo? Php ha preso ogni parametro ricevuto, nell'ordine da sinistra verso destra, gli ha assegnato un indice partendo da zero e lo ha inserito in un array. Ora ogni dato è un elemento dell'array. Possiamo, quindi, gestire il parametro $numbers all'interno della funzione con qualsiasi logica manipoli un array. Una delle tante logiche utilizzabili, potrebbe essere, ad esempio, il mostrare ogni singolo dato: <?php function splatExample(...$numbers){ foreach($numbers as $number){ echo $number."\n"; } } splatExample(3,56,78,6,13,7,89,100,95); ?> In output vedremo Abbiamo gestito $numbers come un qualsiasi php array utilizzando un ciclo foreach.

Fino a questo momento abbiamo sempre dato un nome alle nostre funzioni per poterle richiamare; in realtá, però, gli sviluppatori php sanno bene che esistono anche delle funzioni che non hanno un nome e che, per sequenza nel codice, (lettura ed esecuzione dall’alto verso il basso) non appena vengono "incontrate" si attivano: sono le cosiddette funzioni anonime. Le funzioni anonime nascono per adempiere a due scopi specifici: essere assegnate ad una variabile (e, quindi, permetterci di richiamare la funzione utilizzando proprio il nome della variabile); essere utilizzate come funzioni di callback (ossia funzioni che vengono utilizzate come parametri reali di altre funzioni) In questa situazione possiamo dire che il linguaggio php tratta le funzioni come un valore: un valore che puo essere assegnato ad una variabile oppure un valore che può essere passato come parametro reale ad un altra funzione; quando una funzione accetta tra i suoi parametri a sua volta una funzione, o restituisce, come tipo di ritorno una funzione, viene detta “funzione di ordine superiore” Vediamo qualche esempio ed utilizzo delle funzioni anonime: <?php $sum = function($a, $b){ return $a+$b; }; echo $sum(4,5); ?> In output avremo come risultato 9, vale a dire la corretta somma fra i due numeri. La prima osservazione che possiamo fare, è che la nostra funzione ha un ";" dopo la graffa di chiusura; questo ci dice che quello che abbiamo scritto è un'espressione che verrà tradotta come una funzione e trattata come tale.  Nel nostro esempio, abbiamo visto come una funzione anonima potrebbe essere sfruttata assegnandola ad una variabile, richiamandola attraverso la variabile stessa. Con questa metodologia possiamo, anche, sfruttare parametri esterni alla funzione, facendoli entrare in un modo diverso rispetto a quanto abbiamo fatto fino ad ora <?php $num1 = 5; $num2 = 12; $sum = function() use($num1, $num2){ return $num1+$num2; }; echo $sum(); ?> In output avremo come risultato 17, la corretta somma fra i due numeri. Come vedi, con la keyword "use" diciamo alla funzione di utilizzare le variabili nello scope esterno. La domanda sorge spontanea: adesso che conosciamo questa keyword, quindi, potremmo anche fare quanto a seguire? <?php $num1 = 5; $num2 = 12; function sum() use($num1, $num2){ return $num1+$num2; } sum(); ?> o ancora peggio <?php $num1 = 5; $num2 = 12; function sum(use($num1, $num2)){ return $num1+$num2; } sum(); ?> La risposta é assolutamente no!.  In questi casi non possiamo utilizzare la keyword “use” perchè stiamo dichiarando la funzione tramite la keyword “function” e non come funzione anonima. La differenza tra le due è che la funzione è un costrutto, la funzione anonima è una espressione tradotta e trattata come funzione; solo nel secondo caso possiamo utilizzare la keyword "use". Abbiamo detto che una funzione anonima può essere utilizzata come funzione di callback. Ci sono funzioni built-in, ad esempio, che si aspettano come uno dei propri parametri una funzione di callback; vediamo una: Array reduce, dalla documentazione: array_reduce() applica iterativamente la funzione di callback agli elementi dell'array, in modo da ridurlo ad un unico valore. "array_reduce(array $array, callable $callback, mixed $initial = null): mixed" Come vediamo, la nostra funzione si aspetta come secondo parametro una funzione di callback; useremo, quindi, una funzione anonima (l'ultimo parametro possiamo ometterlo): <?php function sum(...$numbers){ $result = array_reduce($numbers, function($accumulator, $number){ return $accumulator += $number; }); return $result; } $result = sum(3,56,78,6,13,7,89,100,95); echo $result; //In output avremo: //447 ?> Abbiamo costruito una funzione anonima all'interno dei parametri della funzione "array_reduce" che dovrá seguire delle regole ben specifiche descritte nella documentazione: "callback(mixed $carry, mixed $item): mixed" dove “carry” contiene il valore restituito dell'iterazione precedente (nel caso della prima iterazione mantiene, invece, il valore di initial), mentre “item” contiene il valore dell'iterazione corrente. In soldoni, carry è il nostro accumulatore: una variabile che parte da un valore (null nel nostro caso) e, di volta in volta, verrà aggiornata con la somma dell'item, il nostro $number, il singolo numero catturato, in ordine da sinistra verso destra, dal nostro array di numeri $numbers. Dunque, non abbiamo inventato dal nulla la nostra funzione di callback anonima: abbiamo seguito la documentazione e creato una funzione di conseguenza. Attenzione! Le funzioni di callback non sono necessariamente funzioni anonime!  Infatti, la documentazione PHP vanta anche numerosi esempi in cui non sono utilizzate funzioni anonime. Proviamo, quindi, a costruire il precedente esempio con una funzione standard: <?php function callbackFunction($accumulator, $number){ //return $accumalotor = $accumalotor + $number; return $accumulator += $number; }; function sum(...$numbers){ $result = array_reduce($numbers, "callbackFunction"); return $result; } $result = sum(3,56,78,6,13,7,89,100,95); echo $result; //In output avremo: //447 ?> Possiamo dire che array reduce è un classico esempio diu fuzione di ordine superiore.

Considerando ancora i parametri reali passati ad una funzione, nel linguaggio di programmazione PHP esistono dei casi - ma non sono uno standard - in cui una funzione è utilizzata e chiamata ricevendo un numero di parametri reali inferiore ai parametri formali dichiarati nella funzione. Se provassimo a togliere dei parametri reali nei nostri esempi precedenti, sicuramente avremmo un errore. Quindi, come funziona, esattamente, il passaggio di meno parametri reali del previsto? Tramite il parametro di default, in questi casi, prevediamo che la funzione, nel caso in cui dovesse ricevere meno parametri reali di quanti ne occorrano, debba funzionare restituendoci una valore base (di default). <?php $num1=24; $num2=37; function sum($number1, $number2 = 100){ return $number1+$number2; } $sumResult1=sum($num1); echo "Il risultato della somma con parametro di default é: $sumResult1 \n"; $sumResult2=sum($num1,$num2); echo "Il risultato della somma senza parametro di default é: $sumResult2 \n"; //In output avremo: //Il risultato della somma con parametro di default é: 124 //Il risultato della somma senza parametro di default é: 61 ?> Come vediamo nel risultato, nel momento in cui passiamo un solo parametro reale, la funzione utilizzerá il parametro di default per portare a termine il suo compito (ovvero, in questo caso, fare la somma di due numeri). Nel caso in cui, invece, passiamo due parametri verranno utilizzati i parametri reali ricevuti tralasciando quello di default.

Ora che abbiamo definito cosa sono parametri formali e parametri reali, procediamo con le nostre lezioni php, analizzando un altro concetto cardine nel mondo della programmazione informatica, strettamente collegato alle funzioni: il concetto di SCOPE. Lo scope definisce il contesto in cui una determinata porzione di codice viene eseguita. Può essere globale o locale. Nel caso delle nostre funzioni, avremo a che fare con lo scope locale: tutto quello che sarà dichiarato e manipolato al loro interno non sarà visibile esternamente. In tal senso, possiamo immaginare le funzioni come dei buchi neri: dall'esterno non possiamo vedere nulla al loro interno. Le nostre funzioni “buco nero”, però, hanno una sorta di piccolo tasto ed uno schermo; nel momento in cui premiamo il tasto (ovvero richiamiamo la funzione per attivarla), si attiva un meccanismo al loro interno che ci mostra qualcosa sullo schermo (ciò che, appunto, vediamo concretamente a schermo) Vediamolo nel codice: <?php $num1=24; $num2=37; function sum(){ echo $num1+$num2; } sum(); ?> Questa funzione non ci restituirà il risultato corretto e ci darà dei messaggi di warning, che ci avviseranno che le variabili $num1 $num2 non sono definite. Questo avviene proprio perché dall'interno della funzione non è possibile utilizzare tutto ciò che è dichiarato al suo esterno (in questo caso le variabili $num1 e $num2) Come facciamo, dunque, a rendere le nostre variabili visibili all'interno dello scope? Semplice: le “facciamo entrare” dichiarando la funzione con due parametri formali e, nel momento in cui andremo a richiamarla per utilizzarla, le passeremo le due variabili esterne come parametri reali. <?php $num1=24; $num2=37; function sum($number1, $number2){ echo $number1+$number2; } sum($num1,$num2); ?> Adesso il risultato visualizzato in output sarà corretto. Abbiamo, quindi, aperto il cancello della funzione, fatto entrare le due variabili e mostrato il risultato della loro somma. PHP RETURN Nel codice scritto fino ad ora il risultato della somma apparirebbe scritto nel terminale. Le funzioni, però, non vengono concretamente utilizzate per far apparire un risultato a schermo. Il loro utilizzo pratico, è quello di fornirci un dato che sarà riutilizzato all’interno del nostro codice, esternamente alla funzione.  Per poterlo riutilizzare utilizzeremo la keyword "return" all'interno della funzione. Vediamo un esempio: <?php $num1=24; $num2=37; function sum($number1, $number2){ return $number1 + $number2; } $sumResult = sum($num1,$num2); echo "Il risultato della somma é: $sumResult"; ?> In output vedremo: Questa volta, però, come notiamo nell’esempio, abbiamo avuto la necessità di inserire (assegnare) il risultato della funzione all’interno di una nuova variabile ($sumResult), così da poter effettivamente inserire, successivamente, la variabile in una stringa e mostrare il suo valore effettivo nella nostra echo. Se non avessimo dichiarato la variabile $sumResult, il “”return” sarebbe stato fine a sé stesso e non avremmo potuto utilizzarne il risultato per altri scopi (in questo caso per stamparlo in console, ma le applicazioni avrebbero potuto essere le più svariate) Siamo finalmente riusciti a far entrare variabili esterne nella funzione - utilizzando parametri formali e parametri reali - ma anche a far uscire il risultato dell'elaborazione all’esterno della funzione per utilizzarlo.

Nel campo della programmazione informatica moderna è sempre più facile sentir parlare di programmazione orientata agli oggetti. Sicuramente ti è già capitato, vero? Ma che cos'è la programmazione ad oggetti? L’Object Oriented Programming, o OOP, è un paradigma basato essenzialmente su due concetti, che ci guidano nella stesura del codice: stiamo parlando del concetto di classe e quello di oggetto. La programmazione ad oggetti aiuta a strutturare un software in blocchi riutilizzabili di codice, i quali sono, a loro volta, utilizzati per creare istanze individuali di oggetti. Esposto in questo modo può sembrare un concetto molto complesso! In realtà, però, per capirne i meccanismi ci basta pensare agli insiemi con cui giocavamo alle scuole elementari. Confuso? Non preoccuparti. Svisceriamo insieme la metafora nel prossimo articolo

Suggerendoti di pensare agli insiemi delle scuole dell'infanzia, stavamo effettivamente introducendo, se vogliamo, il concetto di classe. Le classi, nei linguaggi di programmazione in generale, ma in questa sede in PHP , ci consentono, infatti, di fare una classificazione di elementi che, nella nostra realtà, hanno delle caratteristiche in comune. Non molto distanti dagli insiemi di cui sopra, giusto? Caratteristiche comuni, dunque, fanno in modo che un dato elemento appartenga ad un insieme e non ad un altro. Pensaci bene: viviamo ogni giorno, nella nostra quotidianità, Il concetto di classe e classificazione, quando andiamo a raggruppare degli elementi tenendo conto delle loro caratteristiche più evidenti: nell’armadio riporremo tutti i vestiti, nel frigorifero tutti gli alimenti e così via. Immaginando un gruppo di persone, per esempio, sicuramente potremo trovare degli elementi in comune tra tutti loro: il nome, il cognome o l’età, per citarne alcuni. “Persona”, quindi, potrebbe diventare un ottimo esempio per definire una classe; nome, cognome ed età, invece, rappresenteranno le caratteristiche di una persona, comuni a tutte le persone. CLASSI PHP: LA SINTASSI Nel linguaggio PHP una classe si definisce tramite la keyword class e con il suo nome, che, però, deve rispettare determinate regole: Dev’essere in inglese; Deve avere la lettera iniziale maiuscola; Dev’essere al singolare. <?php class Person {} ?> Vediamo l'anatomia di una classe. Una classe, al suo interno, è composta da tre parti principali: Gli attributi o proprietà; Una funzione costruttore; I metodi o comportamenti. GLI ATTRIBUTI IN PHP  Gli attributi sono quelle caratteristiche che accomunano tutti gli appartenenti a quella classe e si dichiarano all’inizio della stessa. Abbiamo detto, precedentemente, che ogni persona è caratterizzata da un nome, un cognome e un’età. Tradurremo in codice in questo modo: <?php class Person { public $name; public $surname; public $age; } ?> Come vedi, abbiamo specificato che ogni oggetto della classe Person avrà quelle determinate caratteristiche (o attributi). La classe, scritta in questo modo, tuttavia, è incompleta, in quanto non abbiamo la possibilità di creare degli oggetti da essa. Ma che cos'è un oggetto? Per oggetto si intende un’istanza appartenente a una classe specifica, ovvero un dato che durante l’esecuzione di un programma è presente nella memoria del nostro pc come entità. E’ per questo che abbiamo bisogno di una funzione particolare nota come funzione costruttore, il cui compito sarà prendere in ingresso degli argomenti reali e assegnarli all’istanza che stiamo creando. Vediamolo in codice: <?php class Person { public $name; public $surname; public $age; public function __construct($name, $surname, $age){ $this->name = $name; $this->surname = $surname; $this->age = $age; } } $persona = new Person(‘Giuseppe’, ‘Verdi’, 56); ?> In questo modo, abbiamo specificato al nostro algoritmo come i dati “Giuseppe” “Verdi” “56” debbano andare a creare l’istanza di classe Person che salveremo in $persona. Analizziamo, però, la funzione costruttore: Il suo nome deve essere necessariamente “__construct”, altrimenti non sarà riconosciuta come costruttore. Infatti, questa funzione viene richiamata quando l’algoritmo incontra la keyword new appaiata al nome di una classe; Essendo una funzione, il costruttore accetta dei parametri in ingresso, che ricordiamo essere formali, che altro non saranno che i nostri attributi; Importantissima è la pseudo-variabile $this che sta a indicare l’oggetto che andremo a creare. Infatti, non dobbiamo mai dimenticare che noi stiamo creando, tramite la classe, una mera descrizione e non un oggetto effettivo. In soldoni, stiamo dicendo alla funzione che, dell’oggetto della classe Person che andremo a creare, dovrà catturare l’argomento reale ricevuto nel costruttore e valorizzarne l’attributo assegnato. Adesso siamo in grado di creare illimitate istanze della classe Person, ma un oggetto così costruito è ancora poco efficace. Come detto in precedenza, una classe può avere anche dei metodi o comportamenti ad essa legati. METODI O COMPORTAMENTI Una persona compie, nella sua quotidianità, una quantità infinita di azioni che noi possiamo racchiudere e descrivere attraverso quelli che chiamiamo metodi o comportamenti. Un esempio comune è la possibilità per una persona di presentarsi. Andiamo a vedere come tradurre questo comportamento, appunto, in codice: <?php class Person { public $name; public $surname; public $age; public function __construct($name, $surname, $age){ $this->name = $name; $this->surname = $surname; $this->age = $age; } public function presentati( ){ echo “Ciao, sono $this->name $this->surname e ho $this->age anni.\n”; } } $persona = new Person(‘Giuseppe’, ‘Verdi’, 56); $persona->presentati( ); //Output //Ciao, sono Giuseppe Verdi e ho 56 anni. ?> La funzione presentati( ) è un metodo che permette a tutte le istanze di classe Person di presentarsi e mostrare tutti i valori relativi ai loro attributi. Non è diversa dalle funzioni che abbiamo presentato nel capitolo dedicato. Osserva la sintassi. Cosa noti? Tramite la freccia, non facciamo altro che entrare nell’oggetto specificato ($persona) e catturare ciò che segue (il metodo presentati(), nel nostro caso). Questo tipo di sintassi ci permette di accedere a tutti gli elementi di un’istanza, che si tratti di metodi o di attributi. <?php class Person { //attributi public $name; public $surname; public $age; //costruttore public function __construct($name, $surname, $age) { $this->name = $name; $this->surname = $surname; $this->age = $age; } //metodo public function presentati(){ echo "Ciao, sono $this->name $this->surname ed ho $this->age anni.\n"; } } $persona = new Person('Giuseppe','Verdi','56'); echo $persona->name; //Output //Giuseppe ?> Anche in questo caso, l’utilizzo della pseudo-variabile $this si riferisce all’oggetto che andremo a creare, sempre per lo stesso concetto che con la classe non creiamo nulla ma andiamo solo a descrivere qualcosa.   ATTRIBUTI E METODI STATICI Altri elementi molto utilizzati nella programmazione ad oggetti sono quei metodi e attributi definiti statici. Per definizione, gli attributi e metodi statici non agiscono per conto di un oggetto ma direttamente per conto di una classe. Cosa vuol dire? La definizione ci indica che possiamo richiamare gli attributi ed attivare i metodi senza dover necessariamente istanziare ogni volta un oggetto specifico. Vediamo un esempio: <?php class Person { //attributi public $name; public $surname; public $age; //attributo statico public static $counter=0; //costruttore public function __construct($name, $surname, $age) { $this->name = $name; $this->surname = $surname; $this->age = $age; } //metodo public function presentati(){ echo "Ciao sono $this->name $this->surname ed ho $this->age anni! \n"; } } echo Person::$counter; //Output //0 ?> Nell’esempio abbiamo creato un attributo statico caratterizzato dalla keyword “static”, seguita dalla dichiarazione della variabile a cui abbiamo assegnato un valore iniziale 0. Abbiamo creato questo counter con l’obiettivo di contare quanti oggetti della classe Person saranno stati creati in un certo punto del nostro algoritmo. Come notiamo, immediatamente, nel nostro codice, dove vogliamo far mostrare il valore della variabile attraverso il comando php echo, non abbiamo piú usato la sintassi $oggetto->attributo  ma direttamente la classe Person seguita dallo SCOPE RESOLUTION OPERATOR(::) , un operatore che permette di accedere a dei metodi o proprietà statiche, costanti o sovrascritte di una classe. Nel nostro caso, questo operatore attiverà la ricerca della classe Person e, al suo interno, andrà a cercare un attributo statico, con nome corrispondente a quello indicato, il nostro $counter. Attenzione! Quando vogliamo catturare un attributo statico, dopo lo scope resolution operator dobbiamo, necessariamente, usare il $ Se facciamo partire il nostro programma, vedremo che ci darà come risultato 0, che é esattamente il valore di $counter.  Adesso proviamo a far incrementare questo contatore creando tanti oggetti della classe Person. Essendo la funzione costruttore che “guida” l’istanziamento di un oggetto, è proprio al suo interno che dovremo gestire l’incremento di $counter. <?php class Person { //attributi public $name; public $surname; public $age; //attributo statico public static $counter=0; //costruttore public function __construct($name, $surname, $age) { $this->name = $name; $this->surname = $surname; $this->age = $age; self::$counter++; } //metodo public function presentati(){ echo "Ciao sono $this->name $this->surname ed ho $this->age anni! \n"; } } $persona1 = new Person('Giuseppe','Verdi','56'); $persona2 = new Person('Paolo','Rossi','48'); $persona3 = new Person('Guglielmo','Bianchi','56'); echo Person::$counter; //Output //3 ?> Nel costruttore abbiamo inserito l’incremento del contatore ma non utilizzando più la pseudo variabile “$this” seguita dalla “->” ma una nuova keyword “self”.  Se “$this” si riferisce all’oggetto che andremo a creare, la keyword “self” si riferisce, invece, esattamente alla classe: quindi, ogni qual volta viene richiamata la funzione costruttore (ad ogni new Person nel mio algoritmo), diremo alla classe di recuperare il suo stesso attributo statico $counter, aumentandolo di uno. Se avviamo il programma, in output avremo come risultato 3 che, effettivamente, é il numero di oggetti Person creati nel nostro algoritmo. E se volessimo creare una funzione che mostri il nostro contatore senza catturarlo direttamente dalla classe? In quel caso, avremmo bisogno di un metodo statico: <?php class Person { //attributi public $name; public $surname; public $age; //attributo statico public static $counter=0; //costruttore public function __construct($name, $surname, $age) { $this->name = $name; $this->surname = $surname; $this->age = $age; self::$counter++; } //metodo public function presentati(){ echo "Ciao, sono $this->name $this->surname ed ho $this->age anni.\n"; } //metodo statico public static function showCounter(){ echo self::$counter; } } $persona1 = new Person('Giuseppe','Verdi','56'); $persona2 = new Person('Paolo','Rossi','48'); $persona3 = new Person('Guglielmo','Bianchi','56'); Person::showCounter(); //Output //3 ?> Se eseguiamo il nostro programma, vedremo lo stesso risultato dell'esempio precedente ma, questa volta, abbiamo utilizzato una metodologia di scrittura del codice piú elegante, che nasconde, tuttavia, un effettivo motivo: tra poco, infatti, affronteremo gli access modifiers o indicatori di accessibilità. Gli access modifiers vanno a gestire la visibilità di determinati dati all’interno del nostro algoritmo: vedremo che taluni possono essere resi “privati” e, quindi, invisibili se non richiamati tramite un metodo, ma lo affronteremo nella prossima guida, in relazione all’ ereditarietà. Stay tuned! 

Proseguendo il nostro viaggio per imparare php, vediamo, ora, uno dei vantaggi principali della programmazione orientata agli oggetti. Con la programmazione ad oggetti, infatti, abbiamo la possibilità di ridurre la duplicazione del codice (ovvero, la scrittura dello stesso codice più di una volta), grazie all’ aiuto dell’ereditarietà.  In ereditarietà abbiamo una classe,  definita “genitore”, con i suoi metodi e le sue proprietà, e una o più classi “figlie”, che possono usufruire del codice della classe genitore.  Utilizzando l’ereditarietà, possiamo progettare un pezzo di codice riutilizzabile ogni qual volta servisse. PHP consente l’ereditarietà singola; in altri linguaggi di programmazione, tuttavia, è anche possibile utilizzare l’ereditarietà multipla, dove una classe può ereditare metodi e proprietà da più di una classi padre. In php è utile pensare alla classe figlia come ad una specializzazione della classe genitore. Creazione di una classe estesa in PHP Pronto a seguire gli step per la creazione di una classe estesa in php? Bene! Per rinfrescarci la memoria, andiamo a ribadire come si crea una classe. class Person { //attributi public $name; public $surname; public $age; public function __construct($name, $surname, $age) { $this->name = $name; $this->surname = $surname; $this->age = $age; } } $persona1 = new Person("Mario" , "Rossi" , 26); Ha funzionato? Perfetto! Proviamo, ora, a creare la prima classe che estende la classe Persona: class Teacher extends Person { public $salary; public $subjects = []; public function __construct($name , $surname, $age, $subjects, $salary){ parent::__construct($name, $surname, $age); $this->salary = $salary; $this->subjects = $subjects; } } Utilizzando la parola chiave extends ,  stiamo dichiarando che una classe eredita proprietà e metodi da un’altra classe. Possiamo dire che teacher è una specializzazione di person, infatti ha tutte le caratteristiche di person ma a queste ne aggiunge altre. Vediamo il caso in generale:  class Person { //Codice della classe padre } class Teacher extends Person { //Codice della classe figlia } A questo punto andiamo a creare un’ altra classe figlia, diversa da Docente, ma sempre collegata alla classe padre Persona. class Student extends Person { public $average; public $subjects = []; public function __construct($name , $surname, $age, $subjects, $average){ parent::__construct($name, $surname, $age); $this->average = $average; $this->subjects = $subjects; } } Le classi figlie possono, così, utilizzare gli attributi ereditati dalla classe padre. Questo è possibile perché nella funzione costruttore della classe figlia, richiamiamo la funzione costruttore della classe padre, passando i parametri che verranno assegnati agli attributi ereditati. Ricordi quando, nella guida precedente, abbiamo parlato degli access modifiers o indicatori di accessibilità? È giunta l’ora di approfondire. Se sei stato attento, avrai certamente notato che, fino ad ora, nei nostri esempi, abbiamo impostato gli attributi dichiarati sempre con la keyword “public”. Perché l’abbiamo fatto? La keyword prima del nome dell’attributo indica la visibilità dell’attributo stesso. Per essere più precisi, il punto del programma dove può essere richiamato l’attributo. Oltre a public, che abbiamo utilizzato finora, ci sono altri due tipi di visibilità: protected e private. Gli attributi dichiarati public sono visibili e accessibili in tutte le parti del programma, mentre gli attributi dichiarati con protected e private sono visibili solo all’interno della classe stessa. Vediamo un piccolo esempio: class Person { public $name; protected $surname; public function __construct($name, $surname) { $this->name = $name; $this->surname = $surname; } } $persona1 = new Person("Mario", "Rossi"); var_dump($persona->name); //Mario var_dump($persona1->surname); //Cannot access protected property Person::$surname Come possiamo vedere, il var_dump() di name restituisce il valore, mentre quello di surname restituisce un errore perchè è una proprietà protected e non vi si può accedere dall’esterno. Per potervi accedere, abbiamo bisogno di un metodo che acceda alla proprietà dall’interno della classe. public function tellMeYourSurname(){ echo "My surname is $this->surname"; } $persona1->tellMeYourSurname(); //My surname is Rossi Visto che siamo riusciti ad accedere in lettura, possiamo riuscire ad accedervi anche in scrittura, quindi possiamo modificarlo utilizzando un metodo. $persona1 = new Person("Mario", "Rossi"); //Public $persona1->name = "Giorgio"; var_dump($persona1->name);//Giorgio //Protected public function changeSurname(){ $this->surname = "Verdi"; } $persona1->changeSurname(); $persona1->tellMeYourSurname(); //My surname is Verdi Gli attributi private, invece, vengono ereditati dalle sottoclassi, ma rimangono, comunque, visibili nella classe in cui sono dichiarati.

Stanco? Resisti! Fai un break e continuiamo, le nostre lezioni php non sono ancora finite! Parliamo, in questo articolo, di una tipologia particolare di classe php: le classi astratte. Una classe astratta è una classe che vanta almeno un metodo astratto.  I metodi astratti possono avere esclusivamente nomi ed argomenti. Pertanto, non possiamo creare oggetti da classi astratte. Come scavalcare questo ostacolo? Semplice: dovremo creare delle classi figlie che aggiungano il codice nei corpi dei metodi e utilizzare queste stesse classi figlie per creare oggetti. Se ci pensiamo, nel mondo reale, “parallelepipedo” è una classe astratta: non esiste nel mondo reale un parallelepipedo, ma esistono delle specializzazioni come ad esempio una scatola di scarpe, un televisore, una lavatrice. Sono tutti parallelipepidi, ma che possono esistere nel mondo reale, in quanto specializzati. Vediamolo un po’ meglio, scendendo nel pratico.  Una delle prime cose che dobbiamo fare è istituire la classe Persona con una generalizzazione ( funzione astratta ). abstract class Person { public $name; public $surname; public $age; public function __construct($name, $surname, $age) { $this->name = $name; $this->surname = $surname; $this->age = $age; } abstract function presentati(); } La funzione presentati() nella classe Persona indica che tutte le classi che estendono la classe Persona si possono presentare. Ogni sottoclasse, però, può farlo in modo diverso, esplicitando come. Riprendendo come esempio le classi create nell’articolo precedente, Il Docente si presenterà: class Teacher extends Person { public $salary; public $subjects = []; public function __construct($name , $surname, $age, $subjects, $salary){ parent::__construct($name, $surname, $age); $this->salary = $salary; $this->subjects = $subjects; } public function presentati(){ echo "Ciao, sono $this->nome e sono un Docente"; } } Mentre lo studente: class Student extends Person { public $average; public $subjects = []; public function __construct($name , $surname, $age, $subjects, $average){ parent::__construct($name, $surname, $age); $this->average = $average; $this->subjects = $subjects; } public function presentati(){ echo "Ciao, sono $this->nome e sono uno Studente"; } } Ora che abbiamo costruito le classi, visualizziamo i risultati finali: $docente = new Teacher("Mario" , "Rossi"); $docente->presentati(); //Ciao, sono Mario e sono un Docente $studente = new Student("Giorgio" , "Verdi"); $studente->presentati(); //Ciao, sono Giorgio e sono uno studente Concludendo il nostro primo incontro con il concetto di astrazione, ora sappiamo che questa ci consente di vincolare le classi figlie ai nomi dei metodi e non ai corpi dei metodi.

Abbiamo visto, nelle precedenti guide, i vantaggi della programmazione ad oggetti; tuttavia, non è tutto oro ciò che luccica, e occorre precisare che l'Object Oriented Programming ha anche dei problemi che ti troverai a fronteggiare. Quando lavoriamo all'interno di linguaggi di programmazione che utilizzano l'OOP, infatti, uno dei più grandi problemi da affrontare è quello delle dipendenze. Per fortuna, ci sono dei mezzi che possono aiutarci sotto questo punto di vista: il più famoso è un pattern di progettazione noto come Dependency Injection. Cosa sono le dipendenze? Prima di addentrarci nella Dependency Injection, però, è importante capire che cos'è una dipendenza. Una dipendenza è definibile nella programmazione informatica come un legame esistente tra varie componenti di un'applicazione per cui il funzionamento di una parte "dipende", appunto, dalla natura e dalla presenza delle altre parti. Facciamo l'esempio di un computer: sappiamo che non può funzionare senza scheda madre. Questo si traduce con la classe "Computer" (dipendente) che non può funzionare senza la classe "MotherBoard" (dipendenza) e che, quindi, non potremo utilizzare la prima senza coinvolgere necessariamente la seconda. Un esempio del genere riesce facilmente a veicolare uno degli aspetti critici della presenza delle dipendenze: il nostro progetto sarà molto meno flessibile, impattando negativamente sul riutilizzo di una classe, e, quindi, sulla velocità di sviluppo, sulla qualità e sulla leggibilità del codice. Cos'è la Dependency Injection? Una volta assodato cosa sono le dipendenze, possiamo cominciare a parlare del concetto di Dependency Injection.  Proviamo a tradurre in codice l'esempio del computer di cui sopra: class Computer { public $motherBoard; public function __construct($type){ $this->motherBoard = new MotherBoard($type); } } $computer = new Computer('ATX'); In questo modo, creare un'istanza di Computer è molto semplice e veloce, ma mostra il fianco in termini di customizzazione. In relazione a ciò che abbiamo detto prima, è evidente che questo tipo di approccio, che a prima vista può sembrare corretto, porta, inevitabilmente, a delle problematiche. Infatti, così facendo si va a creare, palesemente, la dipendenza all'interno del costruttore. In questo modo la classe Computer è fortemente accoppiata alla sua dipendenza, la classe MotherBoard. Questo vuol dire che una modifica al costruttore di MotherBoard (l'aggiunta, magari, di altre proprietà) si ripercuoterà a cascata su tutte le istanze della classe Computer. Inoltre, gli argomenti passati al costruttore di Computer non c'entrano nulla con il suo scope, essendo utilizzati solo da MotherBoard. Di buona norma, infatti, una classe dev'essere responsabile di una sola cosa. Proviamo, adesso, ad aggiustare il tiro: class Computer { public $motherBoard; public function __construct($motherBoard){ $this->motherBoard = $motherBoard; } } $motherBoard = new MotherBoard('ATX'); $computer = new Computer($motherBoard); Abbiamo fatto un bel passo in avanti, andando ad applicare quella che è la forma più comune di Dependency Injection, iniettando direttamente le dipendenze al costruttore della classe (Constructor Injection). Questo ci da la libertà di modificare MotherBoard senza andare a toccare minimamente la classe Computer. Possiamo anche rendere più "sicura" la creazione di un'istanza di classe Computer utilizzando quella che viene definita type hinting, ovvero andando a specificare che come argomento di costruzione dell'istanza Computer dev'essere passato, necessariamente, un oggetto di classe MotherBoard. class Computer { public $motherBoard; public function __construct(MotherBoard $motherBoard){ $this->motherBoard = $motherBoard; } } $motherBoard = new MotherBoard('ATX'); $computer = new Computer($motherBoard); In questo modo abbiamo un codice molto più facile da leggere e da capire, in quanto attraverso il type hinting, nel caso venisse iniettata una dipendenza non idonea, potremmo accorgercene subito (scatterebbe immediatamente un errore). In conclusione, seppur presentata in primo luogo come aspetto problematico, in verità, in progetti a lungo termine,con continue evoluzioni, la Dependency Injection dà il meglio di sé ed è per questo che è un design pattern fortemente in trend di questi tempi. Sicuramente, applicare la Dependency Injection ha dei costi che alle volte è difficile vedere, come quelli di pianificazione dell'applicazione, ma è indubbio che ne valga la pena. Con classi strettamente accoppiate (il primo esempio del nostro computer), il progetto diviene estremamente complesso da evolvere e da testare, con una semplice modifica su una classe che rischia di inficiare a cascata tutte le altre. Tirando le somme, la Dependency Injection è uno strumento notevole nel mondo degli sviluppatori php, ma ci raccomandiamo di utilizzarla in modo intelligente.

Abbiamo detto che una delle attività fondamentali in un progetto creato con linguaggi di programmazione orientati ad oggetti è stabilire i rapporti tra le classi.  Nella programmazione ad oggetti, due modi di mettere in relazione le classi sono l'ereditarietà (che abbiamo affrontato precedentemente) e l'Object Composition, che analizzeremo in questo articolo. Come abbiamo potuto capire, la relazione di ereditarietà rende difficile cambiare la classe padre, in quanto queste modifiche andrebbero a ripercuotersi su tutte le classi figlie che, quindi, andrebbero riadattate. In tal senso, invece, la composizione prevede un approccio che rende assai più semplice modificare il codice. Inoltre, al contrario dell'ereditarietà, la composizione è più dinamica, in quanto ogni oggetto può essere rimpiazzato da un altro oggetto purchè, però, sia dello stesso tipo.  Non di meno, evita anche la costruzione di gerarchiche classi enormi e quindi poco gestibili. Di contro, l'Object Composition è, però, più complessa dell'ereditarietà, in quanto porta a un aumento del numero degli oggetti istanziati. Confuso? Non temere. Andiamo a tradurre quanto detto in codice, riutilizzando il nostro caro esempio precedente del computer. Creazione di un oggetto tramite Composition Nell'esempio del capitolo precedente, parlando della Dependency Injection, abbiamo dichiarato come la classe Computer utilizzasse la classe MotherBoard per funzionare. Essendo MotherBoard un concetto molto ampio (diversi formati, diversi tipi di socket CPU, diversi tipi di RAM supportate ecc.), possiamo pensare di trasformare MotherBoard in una classe astratta. abstract class MotherBoard{ public $format; public $socket; public $ram; } Andiamo, poi, a creare delle classi che estendono la classe astratta, ognuna per ogni tipo di scheda madre. class MsiB550 extends MotherBoard{ public function __construct($format, $socket, $ram){ $this->format = 'ATX'; $this->socket = 'AM4'; $this->ram = 'DDR4'; } } class MsiCreator extends MotherBoard{ public function __construct($format, $socket, $ram){ $this->format = 'E-ATX'; $this->socket = 'TRX4'; $this->ram = 'DDR4'; } } Adesso, possiamo tornare al nostro Computer, come lo avevamo lasciato nel precedente capitolo. class Computer { public $motherBoard; public function __construct(MotherBoard $motherBoard){ $this->motherBoard = $motherBoard; } } Grazie alla Object Composition noi possiamo comporre, appunto, un'istanza di classe Computer come vogliamo: infatti, le classi MsiB550 e MsiCreator, estendendo la classe astratta MotherBoard, ne condividono il tipo (o interfaccia). Questo si traduce nella possibilità di richiamare la funzione costruttore, continuando a rispettare il type hinting della Dependency Injection. $computer1 = new Computer(new MsiB550()); $computer2 = new Computer(new MsiCreator()); echo $computer1->motherBoard->format . "\n"; echo $computer2->motherBoard->format; //Output: // ATX // E-ATX Questo tipo di gestione ci ha permesso di creare due istanze di classe Computer completamente diverse tra loro e che potenzialmente possono comportarsi in maniera totalmente differente. Non male, eh? Ereditarietà VS Object Composition: quale utilizzare? Come spesso accade nel mondo della programmazione informatica, uno sviluppatore web può, non di rado, trovarsi davanti ad un bivio. Giunto a questo punto delle nostre lezioni php avrai assimilato le differenze tra Ereditarietà e Object Composition. Ma quale scegliere, tra le due? Non sentirsi spaesato! Dal punto di vista prettamente didattico, dovremmo scegliere tra ereditarietà e composizione in base alla relazione che vogliamo esprimere: l'ereditarietà è da preferire quando un oggetto di una classe figlia è anche un oggetto della classe padre: per esempio, Person -> Teacher. Questo tipo di relazione viene chiamata is-a; In generale usiamo l ereditarietà quando la classe che stiamo creando specializza la classe padre. la composizione, invece, è da preferire quando un'istanza di una classe ha, al suo interno, un'istanza di un'altra classe, senza alcun tipo di legame ereditario: per esempio, Computer -> MotherBoard. Questo tipo di relazione viene definito has-a. Nb. si può trasferire questo ragionamento anche ai metodi: se tutti i metodi di una classe devono essere anche di un'altra, allora si usa l'ereditarietà; se alcuni metodi di una classe non devono essere metodi anche di un'altra, allora si usa l'Object Composition.

Come abbiamo ripetuto diverse volte nelle nostre guide per imparare php, nella programmazione informatica moderna, un grande focus è posto sull'evitare il più possibile la duplicazione del codice. Sappiamo bene, ormai, che un codice duplicato rende la manutenzione del software molto più difficile, in quanto ogni duplicato deve essere mantenuto costante, e che un bug non può essere trovato/risolto in un unico punto. Nell'ambito della programmazione ad oggetti, alcuni limiti strutturali di PHP possono rendere abbastanza complicato mantenere al minimo la duplicazione di codice. Abbiamo anche detto, nei precedenti capitoli, che PHP non supporta l'ereditarietà multipla, e questo potrebbe, ovviamente, portare all'impossibilità di riutilizzare determinati metodi su classi che invece vorrebbero poterli utilizzare senza legarsi con l'ereditarietà. E' proprio per questo che, a partire dalla versione 5.4, PHP implementa un metodo di riutilizzo del codice chiamato Traits. Traits PHP: cosa sono, come si dichiarano, come si usano I traits nascono con l'obiettivo di ridurre alcune limitazioni dettate dall'ereditarietà singola propria di PHP, consentendo allo sviluppatore web di poter riutilizzare una serie di metodi senza che questi debbano essere ereditati da qualche altra classe. Prendiamo ad esempio una classe Person e una classe Dog. class Person{} class Dog{} Sappiamo bene che né persone né cani possono volare, ma, magari, potrebbero volerlo fare. È qui che entrano in gioco i traits: potremmo pensare che, dotando di un jetpack una persona e un cane, essi possano effettivamente poter volare. trait Jetpack { public function volo(){ echo "*Vola alto nel cielo*\n"; } } Quello che dobbiamo fare, adesso, è specificare alla classe Persone e alla classe Dog che possono effettivamente usare un jetpack. class Person{ use Jetpack; } class Dog{ use Jetpack; } Tramite la keyword use, noi stiamo dicendo alle due classi che hanno accesso a tutte le proprietà e metodi del trait Jetpack, potendole quindi utilizzare. $persona = new Person(); $cane = new Dog(); $persona->volo(); $cane->volo(); //Output: *Vola in alto nel cielo* *Vola in alto nel cielo* In questo modo, due classi completamente a sé stanti, non legate in nessun modo, hanno accesso al medesimo metodo volo(). Inoltre, una classe può utilizzare multipli traits, senza alcun tipo di problema, andando a espandere ancor di più le nostre possibilità. Possiamo pensare ai traits come una pennellata che aggiunge dei tratti caratteristici ad una serie di classi che non sono legate da un rapporto di ereditarietà. L'unica cosa da ricordare è che non possiamo chiamare i traits con lo stesso nome utilizzato per una classe, pena un fatal error. In conclusione, i traits rappresentano uno strumento importantissimo che contribuisce a migliorare la progettazione delle nostre applicazioni, rimuovendo la necessità di duplicare il codice e aiutandoci con la pulizia e la manutenibilità dello stesso.

Se sei arrivato fin qui, avrai appreso le basi del linguaggio di programmazione php, ma adesso si fa sul serio! Vediamone una prima applicazione concreta!  Piccola premessa: devi sapere che, in origine, il nome PHP era l’ acronimo di “Personal Home Page” ed è nato come linguaggio di sviluppo specifico per il web; infatti, possiamo scrivere del codice HTML direttamente all’interno di un file PHP e visualizzarlo con il browser!!  Vediamo come!  Come prima cosa creiamo una cartella per il nostro progetto con all’interno un file index.php; all’interno del file inseriamo il template base di html e inseriamo un titolo a piacere: il risultato finale dovrebbe essere più o meno questo. <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Document</title> </head> <body> <h1>Hello World!</h1> </body> </html> Ora non ci resta che avviare un server php nella cartella del progetto con questo comando php -S localhost:8000 apriamo, quindi, il nostro browser preferito e andiamo su localhost:8000 Ed ecco il risultato finale! La nostra pagina HTML sarà online. Avrai notato, però, che non c’è, ad ora, nulla di nuovo rispetto alla semplice pagina html. Cosa è cambiato, dunque? Facile! Adesso possiamo iniziare a inserire delle variabili create con php all’interno dell’html e compilare in questo modo il file finale. Niente male, vero? Proviamo a fare un piccolo passo in avanti e unire quello che abbiamo imparato su php al linguaggio html. <?php $title = 'Hello World from PHP'; ?> <!DOCTYPE html> <html lang="en"> <head> <title>Document</title> </head> <body> <h1><?php echo $title; ?></h1> </body> </html> Benissimo! Se hai letto le precedenti guide ricorderai certamente che il codice php è delimitato (come un elemento html) da un tag di apertura (<?php) e un tag di chiusura (?>). Con il metodo php echo possiamo stampare il valore della variabile “title” all’interno della nostra pagina e ottenere questo risultato.   Benissimo! Adesso che siamo riusciti a stampare una variabile nel nostro foglio html con php echo introduciamo un piccola shorthand che ti farà risparmiare tantissimo tempo: infatti, possiamo sostituire  <?php echo $title; ?> con  <?=$title?> Un piccolo cambio che velocizzerà notevolmente il nostro flusso di lavoro! Cerchiamo, adesso, di fare una cosa un po’ più difficile e creare una serie di informazioni da un php array. <?php $title = "Hello World from PHP"; $users = ['Mario Rossi', 'Luigi Bianchi', 'Giovanni Verdi']; ?> <!DOCTYPE html> <html lang="en"> <head> <title>Document</title> </head> <body> <h1><?=$title?></h1> <h2>Users :</h2> <ul> <?php foreach($users as $user) { ?> <li><?=$user?></li> <?php } ?> </ul> </body> </html> Abbiamo creato l’array users e tramite il foreach di php l’abbiamo ciclato e stampato gli elementi dell’array users. Ecco il risultato che possiamo visualizzare sul browser. Ma che cosa succederebbe se il nostro array fosse vuoto? Ovviamente, non verrebbe stampato nessun nome e la nostra pagina resterebbe vuota. È bene, in questi casi, lasciare sempre un messaggio all’utente che faccia capire che non ci sono ancora utenti e, quindi, non lasciarlo di fronte ad una pagina vuota. Per farlo, utilizzeremo un if statement che mostrerà un messaggio nel caso in cui la lista fosse vuota. index.php <?php $title = "Hello World from PHP"; $users = []; ?> <!DOCTYPE html> <html lang="en"> <head> <title>Document</title> </head> <body> <h1><?=$title?></h1> <?php if (count($users) > 0) : ?> <h2>Users :</h2> <ul> <?php foreach($users as $user) { ?> <li><?=$user?></li> <?php } ?> </ul> <?php else : ?> <p>Non ci sono utenti</p> <?php endif; ?> </body> </html> Ecco come apparirà la nostra pagina nel caso non ci fossero utenti: Proviamo, adesso, a fare un esempio più complesso andando a mostrare una lista di prodotti con delle card e uno stile index.php <?php $title = "Hello World from PHP"; $products = [ [ "id" => 1, "name" => "Divano", "price" => 2500], [ "id" => 2, "name" => "Frigorifero", "price" => 500], [ "id" => 3, "name" => "Lampada", "price" => 95.99] ]; ?> <!DOCTYPE html> <html lang="en"> <head> <title>Document</title> <link rel="stylesheet" href="./style.css"> </head> <body> <h1><?=$title?></h1> <?php if (count($products) > 0) : ?> <h2>Products :</h2> <div class="products-container"> <?php foreach($products as $product) { ?> <style> .product-card-<?=$product["id"]?> { background-color: hsl(<?=(10 * $product["id"])?> 80% 50%); } </style> <div class="product-card product-card-<?=$product["id"]?>"> <h3><?=$product['name']?></h3> <p><?=number_format($product['price'], 2 , ',', '.') ?> €</p> </div> <?php } ?> </div> <?php else : ?> <p>Non ci sono prodotti</p> <?php endif; ?> </body> </html> style.css .product-card { display: inline-block; flex-direction: column; justify-content: space-between; height: 100%; padding: 1rem; border: 1px solid #eaeaea; border-radius: 5px; box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1); transition: all 0.3s ease; margin: 20px; } .products-container { display: flex; flex-wrap: wrap; } Abbiamo creato una pagina più complessa con un file css per modificare lo stile di base delle card e con un foreach abbiamo ciclato l’array dei prodotti. Per ogni prodotto, poi, abbiamo creato una classe specifica che facesse riferimento all’ID del prodotto e applicato un colore di background diverso. Nella sezione del prezzo abbiamo, infine, inserito la funzione number_format che permette di scegliere il formato di visualizzazione dei numeri. In questo caso, abbiamo scelto che ci siano sempre due numeri dopo la virgola, di separare le migliaia con il punto e i decimali con la virgola. Come possiamo notare, il nostro file index sta diventando sempre più grande e complesso e, quindi, adesso ci occorre un metodo per mettere in ordine il nostro codice.   Php Include Con il metodo php include possiamo includere un file all’interno di un altro e separare in questo modo i vari componenti.  Facciamo una prova con il nostro file index e separiamo la card del prodotto dal resto. Creiamo, quindi, una cartella components all’interno della quale possiamo inserire i nostri file specifici per ogni componente. product_card.php <style> .product-card-<?=$product["id"]?> { background-color: hsl(<?=(10 * $product["id"])?> 80% 50%); } </style> <div class="product-card product-card-<?=$product["id"]?>"> <h3><?=$product['name']?></h3> <p><?=number_format($product['price'], 2 , ',', '.') ?> €</p> </div> index.php <?php $title = "Hello World from PHP"; $products = [ [ "id" => 1, "name" => "Divano", "price" => 2500], [ "id" => 2, "name" => "Frigorifero", "price" => 500], [ "id" => 3, "name" => "Lampada", "price" => 95.99] ]; ?> <!DOCTYPE html> <html lang="en"> <head> <title>Document</title> <link rel="stylesheet" href="./style.css"> </head> <body> <h1><?=$title?></h1> <?php if (count($products) > 0) : ?> <h2>Products :</h2> <div class="products-container"> <?php foreach($products as $product) { ?> <?php include('./components/product_card.php') ?> <?php } ?> </div> <?php else : ?> <p>Non ci sono utenti</p> <?php endif; ?> </body> </html> in questo modo ogni componente che andremo a creare potrà essere riutilizzato in altre pagine php, un esempio potrebbe essere l’head del nostro foglio html. Ad oggi, l’intero processo che abbiamo appena descritto viene assai facilitato dagli automatismi di alcuni frameworks del linguaggio php: ne sono un esempio il php template engine “Blade” per il framework Laravel e “Twig” per il framework Symfony. Finisce qui il nostro excursus tra i meandri del linguaggio di programmazione PHP! A questo punto conosci le basi, anche in maniera dettagliata, di questo linguaggio. Puoi approfondire l'apprendimento allenandoti con i nostri esercizi PHP e,  se vuoi veramente fare sul serio con questi frameworks moderni, iscriviti al nostro corso Hackademy! Che ne dici, ti senti pronto a diventare web developer?