62 articoli dell'autore Andrea Pastore

Andrea Pastore 27/09/2020 0

26. Messa in produzione di un progetto

Una volta finito il nostro progetto dobbiamo trasportarlo dal nostro computer al server dove risiederà e sarà fruibile al web. Il server dove risiede il progetto accessibile a tutti è definito server di produzione. Le operazioni più comuni sono il caricamento dei file l’importazione del database, ma può capitare in progetti avanzati di dover fare altre configurazioni.

Caricare file con il protocollo FTP

L’FTP è un protocollo per il trasferimento di dati pensato per caricare file da un computer ad uno spazio web. Per caricare i file del prodotto Geecom che si vuole utilizzare si deve usare un client FTP, ad esempio FileZilla, un programma gratuito scaricabile dal sito http://filezilla-project.org/.

Dopo aver lanciato il programma apparirà questa schermata:

Per caricare i file bisogna stabilire una connessione col sito, riempendo i campi in alto a sinistra del pulsante connessione rapida. Nel campo “Host” bisogna scrivere l'indirizzo del dominio acquistato senza “www.”; nel campo “Nome utente” il nome utente con cui si accede allo spazio web, nel campo “Password” la password per accedere al vostro spazio web. Il campo “Porta” va lasciato vuoto, in questo modo viene usata la porta predefinita.

A connessione avvenuta si possono caricare i file: la finestra a destra mostra le cartelle sul server, quella a sinistra le cartelle del nostro computer. Per portare il nostro progetto online dobbiamo andare nella cartella principale, selezionate tutti i file e trascinarli nella finestra di destra di FileZilla. Il tempo necessario per il caricamento dipende dal numero di file da scaricare.

Leggi tutto

Andrea Pastore 27/09/2020 0

25. Composer

Composer è un gestore di pacchetti per PHP. È nato nel 2015 e da allora si è imposto come lo standard per la gestione delle dipendenze.

Scaricare Composer

Per scaricare Composer visitare il sito https://getcomposer.org/ e a seconda del sistema operativo che avete avrete una diversa procedura di installazione.

Il file composer.json

Il file composer.json contiene tutte le dipendenze per gestire il nostro progetto. Quando dobbiamo utilizzare una libreria esterna ci basterà inserirla in questo file e automaticamente Composer la scaricherà per noi.

Esempio di composer.json :

{

    "require": {

        "monolog/monolog": "dev- master#2eb0c0978d290a1c45346a1955188929cb4e5db7",

        "acme/foo": "1.0.x-dev#abc123"

    },

    "autoload": {

        "psr-4": {

            "Monolog\\": "src/",

            "Vendor\\Namespace\\": ""

        }

    }
Leggi tutto

Andrea Pastore 27/09/2020 0

24. Comunicazione tra server: il mondo delle API

Nel mondo informatico è frequente la necessità di parlarsi tra sistemi diversi. Supponiamo ad esempio che due server della stessa azienda devono scambiarsi informazioni sugli utenti: per fare questa cosa bisognerà prevedere lo sviluppo di file appositi che si connetteranno all’altro server e comunicheranno queste informazioni. Ogni server deve avere anche dei file predisposti per ricevere queste informazioni. Questi file prendono il nome di API. Mentre altri file sul server si occuperanno ad esempio di mostrare i siti o fare altri processi, le API saranno sempre in ascolto ricevere informazioni da uno o più server esterni.

Comunicazione tra server: l’esigenza di una lingua comune

I server possono avere diverse tecnologie, ma questo non deve essere un ostacolo alla comunicazione. Sono state inventate diversi sistemi di interscambio di dati, i più comuni sono il JSON e l’XML.

JSON

JSON sta per JavaScript Object Notation ed è il formato di scambio dei dati più diffuso oggi. Un oggetto JSON inizia e termina con una parentesi graffa, gli elementi al suo interno vengono rappresentati mettendo il nome dell’elemento seguito dai due punti e poi dal valore. Il nome dell’elemento sarà messo tra virgolette, il valore sarà messo tra virgolette solo se è una stringa. Ad esempio:

“nome”:”Mario”

oppure nel caso di un valore numerico:

“età”:5

Nota: dopo ogni elemento (tranne l’ultimo) è necessario mettere una virgola.

Vediamo un esempio di oggetto JSON che contengono le informazioni di una persona:

{
“nome”:”Mario”,
“cognome”:”Rossi”,
“età”:5,
“email”:”mariorossi@virgilio.it”
}

Array in JSON

Il JSON ha la possibilità di raccogliere elementi dello stesso tipo in un array, proprio come la maggior parte dei linguaggi di programmazione. Proprio come nei principali linguaggi di programmazione l’array si crea con le parentesi quadre e al suo interno vanno inseriti gli elementi separati da una virgola. Supponiamo ad esempio di dover rappresentare in JSON un oggetto regione, contenente nome, popolazione, pil e una lista delle principali città. Il campo principali città può essere un array con vari elementi all’interno:

	“principaliCitta”:[“Città 1”,“città 2”];

Un array può contenere anche oggetti. Pensando all’esempio di prima, supponiamo di voler rappresentare le città in maniera più accurata, indicando per ognuna nome, numero di abitanti e la provincia. L’esempio diventerebbe cosi:

	“principaliCitta”:[

{

“nome”:”Firenze”,

“abitanti”:300000,

“provincia”:”FI”

},{

“nome”:”Prato”,

“abitanti”:15000,

“provincia”:”FI”

}],

Esistono dei siti che consentono di validare il JSON scritto, ad esempio:

https://jsonformatter.curiousconcept.com/

Manipolare oggetti JSON con PHP

PHP mette a disposizione delle funzioni che consentono creare e decodificare oggetti in formato JSON: si tratta delle funzioni json_encode e json_decode.

json_encode

Per creare oggetti JSON usiamo la funzione json_encode() che prende in input un array e restituisce un oggetto JSON. Tipicamente useremo questa funzione abbinata alla funzione echo, perché dopo aver creato l’oggetto JSON vorremmo stamparlo. Vediamo un esempio:

           $utente = [

                "nome"       => "Mario",

                "cognome" => "Rossi",

                "email"       => "mariorossi@gmail.com"

           ];

          echo json_encode($utente);

i moderni browser possono formattare i dati JSON, basta indicare nell'header di pagina che si tratta di dati di questo tipo. Questo si fa con il seguente comando:

          header('Content-Type: application/json');

json_decode

La funzione json_decode() serve per decodificare i dati JSON: prende in input una stringa e restituisce l'oggetto a cui possiamo accedere  allo stesso modo in cui accediamo alle proprietà di una classe con variabili pubbliche. Vediamo un esempio:

          $jsonTxt = '{

                                "nome" : "Mario",

                                "cognome" : "Rossi",

                                "email" : "mariorossi@gmail.com"

                            }';

        $jsonObj  = json_decode($jsonTxt);

        // recupero le informazioni

        $nome       = $jsonObj->nome;

        $cognome = $jsonObj->cognome;

        echo "$nome $cognome";

SOAP

Il protocollo SOAP consente di scambiare informazioni tra componenti software utilizzando come fonte di scambio documenti scritti in XML (un metalinguaggio per la definizione di linguaggi di markup, come ad esempio HTML, ideato per consentire agli utenti di creare documenti con markup personalizzati). Era il protocollo di scambio standard prima dell’avvento del JSON, ma conserva una fetta non trascurabile di utilizzo. 

Il file WSDL

Ogni web server ha un file WSDL che contiene la descrizione della sua interfaccia: i parametri necessari ad eseguire le varie operazioni, i messaggi di risposta e cosi via.

La classe SoapClient

PHP mette a disposizione la classe SoapClient per comunicare con i web server SOAP.

Il costruttore di questo dato prende in input un indirizzo web dove è specificato il file WSDL con le opzioni del web server.

         $wsdl  = “linkwsdldelserver.wsdl";

         $soap = new SoapClient($wsdl);

Il metodo doRequest è quello che si occupa di eseguire la richiesta. Restituisce il responso del server, che dobbiamo mettere in una variabile:

         $responso = $soap->__doRequest($wsdl, $location, $action, $version);

Nota: la risposta viene fornita nel formato stdObject, quindi per accedere ai dati dovremmo comportarci come quando recuperiamo i dati di un oggetto, ad esempio:

	echo	$responso->elemento
Leggi tutto

Andrea Pastore 27/09/2020 0

23. I namespace

Un namespace una collezione di nomi di entità, definite dal programmatore, omogeneamente usate in uno o più file sorgente. A partire da PHP 7 anche PHP supporta questo approccio, che ha lo scopo di evitare confusione ed equivoci nel caso siano necessarie molte entità con nomi simili, fornendo il modo di raggruppare i nomi per categorie.

Concettualmente un namespace è assimilabile alla struttura delle cartelle di un filesystem: dobbiamo dichiarare un’origine per il nostro namespace che corrisponde alla directory root, o al nome del disco su sistemi Windows, e possiamo inserire in maniera sequenziale una serie di suddivisioni che in questa similitudine rappresenterebbero le sottocartelle.

Vantaggi dei namespace

Il primo vantaggio è quello di organizzare il codice in modo da facilitare la manutenibilità, ad esempio tramite lo standard PSR-4;

non dobbiamo preoccuparci dei problemi relativi alle omonimie tra classi, ad esempio una classe con un nome molto comune come Connection non sarà più un problema.

 

Leggi tutto

Andrea Pastore 27/09/2020 0

22. I template in PHP

Con la programmazione ad oggetti abbiamo introdotto il paradigma MVC, che consiste nel tener separate la definizione degli oggetti, logiche di controllo e le viste. Un modo ottimale per gestire le viste consiste nell'utilizzo file HTML contenenti il markup dell’elemento, ma con dei valori segnaposto che vengono sostituiti di volta in volta. Questi file HTML vengono chiamati template. Ogni volta che dovrà essere stampato un elemento di quel tipo (si pensi ad esempio a degli articoli) il codice PHP prenderà il template, sostituirà i valori segnaposto con quelli reali ed eseguirà la stampa.

Il vantaggio di questo approccio è ancora una volta nella manutenzione del codice, perché il codice HTML sarà separato dal codice PHP e sarà possibile riutilizzarlo tutte le volte che serve.

Facciamo un esempio su come avviene la gestione: supponiamo di dover inserire in una pagina una serie di articoli. Il codice degli articoli sarà sempre uguale, cambieranno solo i contenuti. Quindi possiamo creare un file che chiameremo articolo.html fatto in questo modo:

<div class=”articolo” >
<h1> _titolo_ </h1>
<h2> _sottottitolo_ </h2>
<p> _testo_ </p>
</div>

possiamo poi creare una funzione PHP che recupera queste informazioni e sostituisce gli articoli ogni volta:

	function renderizzaArticoli($titolo, $sottoTitolo,$testo) {
$codice = file_get_contents(“articolo.html”);
$codice = str_replace(“_titolo_”,$titolo);
$codice = str_replace(“_sottottitolo_”,$sottottitolo);
$codice = str_replace(“_testo_”,$testo);
echo $codice;
}

In questo modo il codice per recuperare gli articoli potrebbe essere:

	$query = “SELECT * FROM articoli”;
if(!$risQuery = $db->query($query)) {
                    echo "Errore durante l'esecuzione della query: ".$db->error;
                    echo "<br>$query";
                exit();
          }

while($articolo = $risQuery→fetch_assoc()) {
renderizzaArticoli($articolo[“titolo”], $articolo[“sottoTitolo”],$articolo [“testo”]);
}

Creiamo una funzione più generalista

La funzione renderizzaArticoli vista sopra svolge il suo dovere per stampare gli articoli ma è troppo specializzata, possiamo usarla solo per questo compito. Questo approccio non è l’ideale, perché ci costringe a creare una funzione per ogni oggetto che dobbiamo renderizzare. 

La soluzione migliore è costruire una funzione generalista, che non prenda parametri precisi ma un template e un array di parametri, che sostituisce di volta in volta:

	function renderizza($template, $parametri) {
$codice = file_get_contents($template);
foreach($parametri as $etichetta => $valore) {
                $ codice = str_replace("_$etichetta_",$valore,$codice);
            }
echo $codice;
}

Possiamo quindi riscrivere il codice visto sopra in questo modo:

	$query = “SELECT * FROM articoli”;
if(!$risQuery = $db->query($query)) {
                    echo "Errore durante l'esecuzione della query: ".$db->error;
                    echo "<br>$query";
                exit();
          }

while($articolo = $risQuery→fetch_assoc()) {
renderizza(“articolo.html”,array(“titolo”=>$articolo[“titolo”], ”sottoTitolo”=> $articolo[“sottoTitolo”], ”testo”=>$articolo [“testo”]));
}

In questo modo quando vorremmo utilizzare la stessa funzione per stampare altri tipi di elementi ci basterà cambiare il template HTML e i parametri dell’array. Un’altra ottimizzazione è quella di chiamare i campi della tabella e del template HTML allo stesso modo, in modo da passare direttamente l’array associativo ricavato dalla variabile $risQuery. Vediamo un esempio:

	$query = “SELECT titolo, sottoTitolo, testo FROM articoli”;
if(!$risQuery = $db->query($query)) {
                    echo "Errore durante l'esecuzione della query: ".$db->error;
                    echo "<br>$query";
                exit();
          }

while($articolo = $risQuery→fetch_assoc()) {
renderizza(“articolo.html”,$articolo);
}
Leggi tutto

Andrea Pastore 27/09/2020 0

21. PHP e i file

PHP, come tutti i linguaggi di programmazione, dispone di una serie di funzioni per gestire i file.

Controllare l’esistenza di un file

Ci sono casi in cui dobbiamo verificare l'esistenza di un file, prima di compiere

determinate operazioni. In tal caso possiamo usare file exists, che restituisce ture

se il file esiste e false altrimenti

     if(file_exists("text.txt")) {

         echo "Il file esiste";

     }

     else {

         echo "Il file non esiste";

     }

La funzione fopen

La funzione fopen è una delle unzioni più popolari per quanto riguarda i file: crea un oggetto che consente la lettura di un file in diverse modalità:

  • lettura
  • scrittura
  • append
  • lettura e scrittura

il secondo parametro ci consente di specificare la modalità del file

  • r sta per lettura
  • w sta per scrittura
  • w+ lettura e scrittura, elimina il contenuto precedente del file
  • a sta per append
  • a+ lettura e scrittura, non elimina il contenuto precedente
     $file = fopen("prova.txt", "r");

     // per leggere un file possiamo usare questo ciclo
     while(! feof($file)) {
        $line = fgets($file); // fgets lette il file una riga alla volta
        echo $line. "<br>";
     }

     /*
      * per scrivere un file oltre ad aprire un file in modalità scrittura
      * con fopen dobbiamo utilizzare la funzione fwrite
      */
     $file2 = fopen("file.txt","w");
     fwrite($file2,$line);

Leggere il contenuto di un file

PHP mette a disposizione altre funzioni per leggere l’intero contenuto del file:

readfile()

     $contenutoFile = readfile("prova.txt");

     echo $contenutoFile; // nota che questa funzione stamperà il contenuto del file e la lunghezza

file_get_contents()

La funzione più utilizzata per leggere sui file, consente anche di specificare se è abilitata la modalità strict path (che non vedremo in questa guida), un eventuale context e  il punto di partenza della lettura e quanti caratteri dobbiamo leggere.

     // in questo esempio leggiamo tutto il contenuto

     $contenutoFile = file_get_contents(“prova.txt”);

     // in questo esempio leggiamo i primi 20 caratteri a partire dall’undicesimo carattere

     $contenutoFile = file_get_contents(“prova.txt”, FALSE, NULL, 20, 14);

Copiare un file

PHP mette a disposizione la funzione copy per copiare un file. Vediamo un esempio:    

     copy("file.txt","nuovoFile.txt");

Con copy è possibile copiare anche file localizzati su server diversi. Per fare questo basta specificare un'url nel primo parametro, ad esempio:

     copy("https:miosito.it/logo.png","nuovoFile.png");
Leggi tutto

Andrea Pastore 27/09/2020 0

20. Le interfacce ed ereditarietà

Vediamo ora altri due concetti fondamentali nella programmazione ad oggetti: le interfacce e l’ereditarietà. Le prime servono per standardizzare il codice, l’ereditarietà invece serve per ottimizzare il codice scritto ed evitare ripetizioni.

Interfacce

Le interfacce vengono utilizzate per definire un tipo di dato e una classe, che però non viene implementato. Vengono definite solo le firme dei metodi che poi saranno implementate in altre classi. Vediamo un esempio di interfaccia:

public interface Libro {

public void stampaLibro();

public void setTitolo(String titolo);

public String getTitolo();

public void setNumeroPagine(int numeroPagine);

public int getNumeroPagine();

}

Per usare una determinata interfaccia dopo il nome della classe dobbiamo usare la parola chiave implements seguita dal nome dell'interfaccia. Appena facciamo questo il nostro IDE ci segnalerà che i metodi dell'interfaccia non sono ancora implementati, clicchiamo su add unimplementated methods (potrebbe cambiare a seconda dell’ide usato) e il nostro IDE li aggiungerà per noi, dobbiamo solo completarli con il codice all'interno.

In sostanza le interfacce consentono di standardizzare il codice: due programmatori si accordano sui metodi e su come vengono chiamati, e poi ai fini dell'interoperabilità delle classi non è importante come viene implementato. Nel tempo le implementazioni possono cambiare, ma rispettandole interfacce non ci saranno problemi di incompatibilità

Ereditarietà

Ci sono casi in cui dobbiamo creare classi molto simili tra loro. Per questo molti linguaggi di programmazione consentono di usare il meccanismo dell’ereditarietà. Supponiamo di avere bisogno di queste due classi:

  • Utente
    id, nome, cognome, indirizzo, telefono
  • Fornitore
    id, nome, cognome, indirizzo, telefono, partita IVA

notiamo che Fornitore è quasi uguale alla classe Utente, quindi non ha senso riscriverla. Quando creiamo la classe Fornitore che estenderà la classe Utente.

Anatomia di una classe

Ogni classe è composta da tre tipi di elementi:

Variabili

le variabili di una classe si dichiarano come le variabili che abbiamo sempre visto, ovvero specificando il tipo di dato (int, double, String e così via) ma in più dobbiamo specificare il tipo di accesso, ovvero public, private, protected. Questo è necessario per utilizzare una caratteristica della programmazione ad oggetti, l’incapsulamento, che vedremo più avanti.

Metodi

I metodi rappresentano le operazioni che possono essere eseguite dagli oggetti di quella classe. Come le funzioni, i metodi possono avere parametri in input e possono essere usati per eseguire le operazioni più varie. Possono anche avere parametri preimpostati come visto nel capitolo delle funzioni.

Anche nei metodi usiamo un indicatore di accesso tra public, private, protected.

Costruttore

una casse di per se è solo un elenco di metodi e variabili, definisce il comportamento di un oggetto ma non viene eseguita direttamente, per utilizzarla dobbiamo creare un oggetto di quel tipo. Per questo ogni classe ha un metodo speciale chiamato costruttore, che serve a creare l’oggetto su cui noi possiamo poi usare i metodi definiti nella classe. Può prendere in input dei parametri con i quali inizializzerà le variabili di classe. Il costruttore si invoca con la parola chiave new seguita dal nome della classe e i parametri che abbiamo stabilito nel costruttore.

Cosa succede quando invochiamo un costruttore?

Quando invochiamo un costruttore di una classe viene creato un oggetto che ha al suo interno le variabili definite da quella classe, che ci mette a disposizione i metodi definiti nella classe. Per ogni classe possiamo creare tutti gli oggetti che vogliamo.

Metodi statici

PHP consente di creare metodi statici, che sono cui metodi il cui output sempre uniforme, che non dipende da variabili di classe. Quando creiamo un oggetto che è un’istanza di una classe normale PHP creerà un oggetto di quella classe su cui noi possiamo eseguire i metodi.  Se invece vogliamo invocare un metodo statico la sintassi è diversa: dobbiamo scrivere il nome della classe seguito dai 2 punti seguiti dal nome del metodo, ad esempio:

	NomeClasse::nomeMetodo();

I metodi statici devono essere preceduti dalla parola chiave static e possono essere utilizzati senza creare un costruttore. Dal momento che i metodi statici possono essere invocati in qualsiasi contesto non possiamo inserire al loro interno eventuali variabili di classe.

Esempio di metodo statico

Vediamo un esempio di metodo statico: immaginiamo di avere una classe esempio con un metodo statico che prende in input un link e un titolo e li stampa in un codice HTML.

class Esempio {

         static function visualizzazioneArticolo($linkContenuto,$titolo) {

            echo"<div class=\"articolo\">

                <h2 class=\"title\"><a href=\"$linkContenuto\">{$titolo}</a></h2>

            </div>\n";

        }

}

Per utilizzare questo metodo scriveremmo:

	Esempio::visualizzazioneArticolo($link,$titolo);

Nota: i metodi statici non possono usare variabili istanza, se proviamo ad accedere ad una proprietà non statica (ad esempio una variabile di classe) otterremo un errore, ad esempio il seguente codice:

class Esempio {
         static function visualizzazioneArticolo() {
            echo"<div class=\"articolo\">
                <h2 class=\"title\"><a href=\"$this->linkContenuto\">{$this->titolo}</a></h2>
            </div>\n";
        }
}

Genera un errore di questo tipo:

Fatal error: Using $this when not in object context in …

Questo perché noi abbiamo provato ad invocare una variabile istanza in un metodo statico, ma dato che quando si usa un metodo statico non è stato proprio creato un oggetto quella variabile non esiste.

Il paradigma MVC

La programmazione ad oggetti è utilizzata nel paradigma MVC (Model, View, Controller), che consente una separazione delle logiche. Vediamo i tre elementi nel dettaglio:

  • model
    sono le classi cosi come le abbiamo viste. Quando creiamo una classe infatti definiamo degli oggetti ma non li usiamo in quell’istante
  • view
    le viste rappresentano la parte del progetto che mostra i dati visivamente
  • controller
    sono i file che consentono di rendere permanenti le operazioni sugli oggetti: creazione di nuovi elementi, modifica di elementi esistenti, eliminazione di elementi e anche recupero dei dati di un elemento. I controller nascondono le logiche sottostanti alle altre classi: potremmo voler salvare i dati in un file oppure nel database, per le classi esterne viene chiamato lo stesso metodo. Facendo passare tutte le operazioni di salvataggio, modifica, caricamento per il controller avremo solo una classe che gestisce queste operazioni, che si traduce in un vantaggio per la manutenibilità del codice, in quanto per apportare modifiche alla gestione degli oggetti dovremmo modificare solo la classe relativa.
Leggi tutto

Andrea Pastore 27/09/2020 0

19. La programmazione a oggetti

Finora abbiamo programmato in modo procedurale, ovvero le istruzioni che abbiamo scritto venivano eseguite una dopo l’altra. Questo sistema di programmazione non è molto efficiente, perché i codici diventano molto grandi e difficilmente manutenibili. La programmazione ad oggetti è nata per risolvere questo problema. Si basa su due principi fondamentali: le classi e gli oggetti. Una classe è un file che definisce un tipo di dato, nonché le operazioni che possono essere effettuate dagli oggetti di quella classe. Sarà possibile poi creare oggetti di quel tipo di dato che possono eseguire le operazioni stabilite.

Caratteristiche programmazione ad oggetti

Le variabili di classe

Una classe può avere variabili proprie, che spesso sono accessibili solo a lei (approfondiremo questa cosa tra poche righe, quando parleremo dell’incapsulamento).  Le variabili di una classe si dichiarano in alto, subito dopo la dichiarazione della classe.

I metodi

I metodi sono delle funzioni che possono essere invocate solo sugli oggetti della classe. Mantengono le stesse proprietà delle funzioni, ma sono applicate solo all’istanza della classe su cui vengono eseguite.

Il costruttore

Il costruttore è un metodo speciale che consente di creare un’istanza dell’oggetto. Viene creato con il metodo __construct, che può prendere in input dei parametri ed inizializzare il nostro oggetto con i loro valori. Il costruttore viene posizionato di solito sotto le variabili di classe.

Incapsulamento

Nelle classi abbiamo la possibilità di scegliere, oltre al tipo di variabile, anche il livello di accesso, tra questi tre valori:

  • public
    se dichiariamo una variabile public questa sarà accessibile anche all’esterno della classe, qualunque parte di un programma potrà leggere quei valori.
  • private
    Se invece la dichiariamo private questi valori potranno essere letti solo all’interno della classe.   
  • protected
    è una via di mezzo: consente la lettura di questa variabile alle classi che estendono la classe che stiamo scrivendo. Vedi il paragrafo successivo sull’ereditarietà.

Nota: in PHP se non scriviamo uno specificatore di accesso i metodi sono public, ovvero possono essere invocati da chiunque.

la regola è quella di dichiarare le variabili private e poi utilizzare dei metodi per restituire o modificare dei valori.

La nostra prima classe in PHP

Creiamo ora la nostra prima classe in PHP. Supponiamo di voler creare una classe che rappresenti un libro, e memorizzare titolo, autore e genere. Il codice di questa classe sarà:

<?php

class Libro {

    private $titolo;

    private $autore;

    private $genere;

    /*

     * Il costruttore in PHP viene creato con il metodo __construct,

     * che può prendere in input dei parametri ed inizializzare il

     * nostro oggetto con i loro valori

     */

    function __construct($titolo, $autore, $genere) {

        $this->titolo = $titolo;

        $this->autore = $autore;

        $this->genere = $genere;

    }

    // getter & setter

    function getTitolo() {

        return $this->titolo;

    }

    function getAutore() {

        return $this->autore;

    }

    function getGenere() {

        return $this->genere;

    }

    function setTitolo($titolo): void {

        $this->titolo = $titolo;

    }

    function setAutore($autore): void {

        $this->autore = $autore;

    }

    function setGenere($genere): void {

        $this->genere = $genere;

    }

}
Leggi tutto

Andrea Pastore 27/09/2020 0

18. L’operatore ternario

Supponiamo di avere il seguente codice che assegna un valore ad una variabile in base all’esistenza o meno di un’altra variabile (nel nostro caso $cliente). In caso affermativo assegna il nome del cliente alla variabile, in caso negativo la inizializza con una stringa vuota.

    if(isset($cliente)) {

        $nomeCliente = $cliente["nome"];

    }

    else {

        $nomeCliente = "";

    }

PHP mette a disposizione un operatore per eseguire lo stesso codice: l’operatore ternario. Questo è composto dai simboli () seguito da un punto interrogativo, seguito da un’istruzione e poi da una seconda istruzione. Vediamo come scrivere lo stesso codice con l’operatore ternario:

    $nomeCliente = (isset($cliente)) ? $cliente["nome"] : "");

È anche possibile usarlo all’interno di echo: supponiamo di avere un codice simile a quello precedente, ma invece assegnare un valore stampa direttamente.

    if(isset($cliente)) {
        echo $cliente["nome"];
    }

    else {
        echo "Il cliente non esiste";
    }

Il codice con l’operatore ternario è il seguente:

    echo((isset($cliente)) ? $cliente["nome"] : "Il cliente non esiste");
Leggi tutto

Andrea Pastore 27/09/2020 0

17. Gestire le date con PHP

PHP mette a disposizione la funzione date per creare le date. Ad esempio per creare la data di oggi dovremmo scrivere:

$data = date(“d/m/Y”);

la funzione date prende come argomento il tipo di formattazione desiderato, ad esempio il codice scritto sopra genererà una data formato italiano, ovvero gg/mm/aaaa. Se avessimo voluto creare una data col formato inglese, avremmo dovuto scrivere:

$data = date(“Y-m-d”);

potrebbe anche capitarci di dover stampare solo l’anno, in questo caso scriveremo:

$data = date(“Y”);

La stessa funzione consente di stampare anche l’ora, scrivendo:

$data = date(“H:i:s”);

la lettera H indica che vogliamo stampare l’ora in formato 24h, mentre la lettera i indica i minuti. La lettera s indica i secondi. Come per la data, possiamo scrivere solo l’ora, solo i minuti o solo i secondi, ma possiamo anche scrivere tutto insieme, ad esempio:

$data = date(“d/m/Y H:i:s”);

Modificare il formato di una data

Capita frequentemente di dover modificare la data, ad esempio perché dobbiamo inserirla nel database e MySQL salva le date nel formato inglese, ovvero aaaa-mm-gg. Per convertire una stringa usiamo nuovamente la funzione date, alla quale però aggiungiamo un altro parametro, che è la conversione della data in millisecondi. Questa operazione si fa con strtotime. Vediamo questo esempio:

	$dataBase = “2015-01-01”;

echo date("d/m/Y", strtotime($dataBase));

Abbiamo passato in input a date un secondo parametro in cui con la funzione strtotime trasformiamo la stringa $dataBase in millisecondi, e poi abbiamo chiesto alla funzione date di formattarla diversamente, nel formato italiano. Il risultato di questa funzione verrà stampato dalla funzione echo. l’output del codice scritto qui sopra è:

	2015-01-01

Tabella con le opzioni della funzione date

Stampa l’anno in formato AAAA 
 y Stampa l’anno in formato AA
 m Stampa il mese informato numerico
 M Stampa il mese in formato testuale (solo le prime tre lettere)
 d Stampa il giorno in formato numerico
 D Stampa il nome del giorno (solo le prime tre lettere)
 H Stampa l’ora in formato 24h
 h Stampa l’ora in formato 12h
 i Stampa i minuti
 s Stampa i secondi
$data = date(“d/m/Y”);

la funzione date prende come argomento il tipo di formattazione desiderato, ad esempio il codice scritto sopra genererà una data formato italiano, ovvero gg/mm/aaaa. Se avessimo voluto creare una data col formato inglese, avremmo dovuto scrivere:

$data = date(“Y/m/d”);
Leggi tutto