PHP Moderno e Avanzato: Da OOP a Design Pattern Professional

Installare laragon

Installare nuova versione di php

Installare xampp su mac

Installare xampp su ubuntu linux

Funzioni variadiche

Funzioni anonime

Arrow functions. php >= 7.4

Funzioni. Parametri passati per valori e

per riferimento

Funzioni. Scope delle variabili. Variabili

locali e globali. global

Definizione tipi di argomenti e tipo di

ritorno

Indicare il tipo di parametro e che può essere null. Ritorno null di funzione

php8: Union types

php8. Named arguments

Codice sorgente della sezione

Str_contains, str_start_with

array_find, array_key_find, array_any, array_all. php >= 8.4

Struttura di controllo. Match . PHP >= 8

Destrutturazione assimetrica di array

Destrutturazione array. php >= 7.4

Consumare API e gestire json con file_get_contents

Leggere dati json con file-get-contets. Mostrare i posts con bootstrap

Passare uno stream context ad file_get_contents

Vedremo cos'è una classe e  cosa sono le sue proprietà 

Il costruttore di una classe serve a impostare delle condizioni iniziali per gli oggetti

Che verranno costruiti e verrà chiamato ogni volta che si crei un oggetto della classe

__construct

class Auto {
    public $color ='';
    public $upholstery;
    
    public function __construct($extColor = null, $intColor = null) {
        $this->color = $extColor;
        $this->upholstery = $intColor;
    }
    public function getColor()
    {
        return $this->color;  
    }
    public function setColor(string $colore)
    {
        if(strlen($colore)<3){
            throw new Exception('Invalid argument');
        }
        $this->color = $colore; 
    }
}

Si possono creare metodi che leggono e impostano proprietà di una classe.

Di solito questi metodi ( per impostare una proprietà) e getter( per leggerla) sono pubblici:

Con  l'attributo extends,  si può indicare ad una classe di estendere (ereditare)  un'altra classe.

Si potranno sovrascrivere i metodi della classe parent e per poter chiamare i metodi della classe parent, bisogna precedere il nome del metodo con parent::

class Auto {

    protected $color = '';
    protected $upholstery;

    public function __construct($extColor = null, $intColor = null) {
        $this->color = $extColor;
        $this->upholstery = $intColor;
    }

    public function getColor() {
        return $this->color;
    }

    public function setColor(string $colore) {
        if (strlen($colore) < 3) {
            throw new Exception('Invalid argument');
        }
        $this->color = $colore;
    }
  public function getUpholstery() {
        return $this->upholstery;
    }

    public function setUpholstery(string $uph) {
       
        $this->upholstery = $uph;
    }
}

class Truck extends Auto {
    
    protected $weight;
    
    public function __construct($extColor = null, $intColor = null, $weight) {
        parent::__construct($extColor, $intColor);
       
        $this->weight = $weight;
      // 
    }
    public function getColor() {
        return strtoupper(parent::getColor());
    }
    public function getWeight(){
        return $this->weight;
    }
     public function setWeight($w){
        return $this->weight = $w;
    }

}

Una interface serve a indicare alle classi che implementeranno l'interface quali sono i metodi da implementare senza che l'interface li debba definire. E' solo un compromesso che si assume la classe di fare l'implementazione di ciascun metodo:

interface iCar {

    public function stop();

    public function start();

    public function changeGear(int $v);

    public function park();

    public function accelerate();
}

class Auto implements iCar {
    
    public $iStopped = true;
    protected  $gear = 0;
    const maxGear = 5;
    protected  $isParked = false;
    public function stop(){
          $this->iStopped = true;
      }

    public function start(){
        $this->iStopped = false;  
      }

    public function changeGear( int $v){
        if($v > self::maxGear){
            $v = self ::maxGear;
        }
        if($v <0){
            $v = 0;
        }
        
        $this->gear = $v;
        if($this->gear>0){
            $this->isParked = $this->isParked= false;
        }
      }

    public function park(){
        $this->iStopped = true;
        $this->isParked = true;
      }

    public function accelerate(){
          
      }
}

Le classi astratte (abstract) non possono essere instanziate. Le classi con almeno un metodo abstract, devono essere abstract.

Le classi che estendono una classe abstract, devono implementare il metodo bastract:

abstract class Car {
    protected $speed = 0;
    
    abstract protected function speedUp(int $v);
    
     public function getSpeed(){
         return $this->speed;
     }
 }
 
 class myCar extends Car{
     protected $speed = 0;
     public function speedUp(int $v) {
         $this->speed += $v;
     }
 }

Metodi e proprietà definiti che static  possono essere chiamati direttamente senza dover instanziare una classe:

abstract class Car {
    
    protected $speed = 0;
    
    public static $classVersion='1';


    abstract protected function speedUp(int $v);
    
     public final function getSpeed(){
         return $this->speed;
     }
     public static function getVersion(){
         return self::$classVersion;
     }
 }

php. Come usare constanti nelle classi

Variabili statiche, self e static nelle classi

Self vs static. Ritornare new self() e new static()

Typed properties. Proprietà tipificate

Constructor property promotion. Proprietà automatiche via constructor

Proprietá solo lettura e classi solo lettura. readonly properties and classes

Nullsafe operator. php >= 8.

PHP >= 8.4: Scrivere Classi Più Pulite ed Espressive con i Property Hooks

Union type

Intersection type