Differenze tra This, Self, Static e Parent in PHP

Approcciare la OOP (Programmazione Orientata agli Oggetti) significa, il più delle volte, bloccarsi di fronte al labirinto logico delle keyword: this, self, static e parent.

In questo approfondimento cercherò di spiegarvi in maniera semplice Cosa sono, Quando servono e Come usarli.

Prima di analizzare nel dettaglio self, static e parent, è necessario comprendere due concetti fondamentali della programmazione ad oggetti:

• Classi
• Ereditarietà

Il $this nelle Classi

Quando si parla di programmazione orientata agli oggetti (OOP) in PHP, è importante fare una premessa teorica:

Un oggetto non è altro che un tipo di dato complesso definito dall’utente (simile agli Array) che segue uno schema ben preciso, chiamato Classe.

Una classe può essere paragonata alle istruzioni di montaggio di un mobile IKEA. Queste istruzioni contengono tutti i dettagli necessari (elenco dei pezzi, passaggi di assemblaggio, specifiche) che permetteranno in futuro la realizzazione materiale del mobile, come ad esempio la famossissma e Best Seller di ogni tempo libreria BILLY.

Quando acquistiamo la libreria, non ci viene spedita montata (sigh!) ma toccherà a noi montarla seguendo quel libricino chiamato “Istruzioni di Montaggio”.

Se siamo bravi e pazienti, riusciremo a montare esattamente BILLY come visto dal vivo nel punto vendita o come da foto sull’eCommerce. IKEA è sicuro che chiunque riuscirà a replicare BILLY in autonomia in quanto le istruzioni date saranno uguali per tutti.

BILLY esiste solo su carta, non è ancora fisicamente assemblato. Tutti gli elementi illustrati (ripiani, viti, pannelli laterali, ecc.) sono dei segnaposto da riempire con i pezzi reali.

Come si vede dall’immagine qui sopra, se nelle istruzioni abbiamo indicato 6 tavole per ripiani, 2 pannelli laterali e 1 pannello posteriore, 18 chiodi ecc… il cliente che assemblerà il mobile utilizzerà quelle istruzioni per costruire realmente una libreria BILLY esattamente come nel progetto.

Seguendo questo esempio, puoi intuire che il $this è il segnaposto da sostituire con il pezzo reale durante l’assemblaggio.

La keyword $this funzionerà solamente nello scope (area di visibilità) della classe:

class LibreriaBILLY {
   public $shelves;

   public function __construct($ripiani, $pannelliLaterali, $pannelloPosteriore) {
       $this->shelves = $ripiani;
   }
}

Fuori dalla classe, non è possibile utilizzare $this:

class LibreriaBILLY {
   public $shelves;

   public function __construct($ripiani, $pannelliLaterali, $pannelloPosteriore) {
       $this->shelves = $ripiani;
   }
}
// $this->shelves = 5; // Questo causerebbe un errore

Dentro la classe utilizzerai il $this per accedere ai metodi e agli attributi della classe. Fuori dalla classe utilizzerai l’oggetto per accedere ai metodi e agli attributi dell’oggetto istanziato.

Dentro la Classe	Fuori la Classe
$this->attributo	$object->attributo

Ecco un esempio pratico:

class LibreriaBILLY {
   public $shelves;
   public $sidePanels;
   public $backPanel;

   public function __construct($ripiani, $pannelliLaterali, $pannelloPosteriore) {
       $this->shelves = $ripiani;
       $this->sidePanels = $pannelliLaterali;
       $this->backPanel = $pannelloPosteriore;		  
   }

   public function assemblaLibreria() {
      echo "Assemblo una Libreria BILLY con $this->shelves ripiani, $this->sidePanels pannelli laterali e $this->backPanel pannello posteriore.";
   } 
}

$miaLibreria = new LibreriaBILLY(5, 2, 1);
$miaLibreria->assemblaLibreria(); // Qui non possiamo usare $this, ma l'oggetto $miaLibreria

Ereditarietà

L’ereditarietà in PHP, come in altri linguaggi di programmazione, è un concetto di astrazione che permette di definire delle classi Figlio partendo da classi Genitore già esistenti.

Questa gerarchia permette di riutilizzare il codice esistente e di evitare di doverlo riscrivere, in quanto le nuove classi erediteranno Attributi e Metodi della classe genitore.

In questo modo, ogni classe figlio può utilizzare tutti i metodi e le proprietà della classe genitore (nonno, bisnonno ecc.), ma ovviamente potrà specializzare altri attributi e metodi propri.

Ecco un esempio semplificato:

class GenitoreRicco {
  public $soldi;    
}

class Figlio extends GenitoreRicco {
  public function spendiTuttoEApriCentroScommesse() {
    return $this->soldi = 0;
  }
}

$antonio = new Figlio(); // Il figlio erediterà tutti i soldi del genitore
$antonio->spendiTuttoEApriCentroScommesse(); // Il figlio ha appena speso tutto

Che cosa sono self, static e parent?

Dopo aver compreso che $this è il segnaposto di un dato futuro, che verrà poi trasformato in un oggetto nel momento dell’istanza di quest’ultimo, è giunto il momento di introdurre il concetto di static.

Static

In PHP, solitamente gli oggetti vengono definiti come dinamici, ovvero vengono istanziati al momento e si valorizzano con i dati di input.

Diametralmente opposta è la parola “static”.

Static è una keyword che viene utilizzata per definire proprietà o metodi statici che sono condivisi da TUTTE le istanze della classe in oggetto e dei relativi figli.

Solitamente hanno un valore di default e non contemplano dati inseriti dinamicamente dall’esterno.

Un attributo o un metodo statico sono definiti nella classe stessa in maniera statica e non in un secondo momento da un’istanza specifica della classe.

class Counter {
    public static $count = 0;
    public static $results = 0;

    public static function test() {
        echo "Funzione statica di test";
    }
}

Questo significa che, non avendo bisogno di input inseriti dinamicamente, si possono richiamare senza creare un’istanza della classe:

class Counter {
    public static $count = 0;

    public static function add() {
        self::$count++;
    }
    public static function sub() {
        self::$count--;
    }
    public static function test() {
        echo "Funzione statica di test";
    }
}

Counter::add();
Counter::sub();
Counter::add();
Counter::test();

echo Counter::$count; // 1

Self

La keyword self indicherà sempre e comunque la classe che lo richiama e potrai utilizzarla all’interno di un metodo statico o di un metodo di una classe. Utilizza il concetto del Sottinteso.

In altre parole, se richiamerai self dentro Classe1, self sarà appunto Classe1. Se invece richiamerai self dentro Classe45, self sarà appunto Classe45.

Il self ti servirà quando proverai ad accedere ad attributi o metodi statici definiti nella classe.

Ecco un esempio corretto di utilizzo di self:

class Articolo {
    public static $title = "Testo Standard";

    public function metodo() {
        return self::$title;
    }
}
 
$nuovo = new Articolo();
echo $nuovo->metodo();

Riassumendo:

Dentro la classe utilizzerai self::, così da poter accedere ai metodi e agli attributi statici della classe. Fuori dalla classe utilizzerai il nome stesso della Classe, così da poter accedere ai metodi e agli attributi statici.

Dentro la Classe	Fuori la Classe
self::$attributo	Classe::$attributo
self::myFunction()	Classe::myFunction()

Parent

La keyword parent rappresenta la classe genitore della classe corrente.

Può essere utilizzata per accedere ai membri e ai metodi della classe genitore.

L’utilizzo di parent è particolarmente utile quando si desidera sovrascrivere un metodo nella classe figlia, ma si vuole anche accedere al metodo originale della classe genitore.

Ecco un esempio in cui sovrascriviamo il costruttore, ma preserviamo il costruttore del genitore:

class ProgettoEdificio {
   public $floor; 

   public function __construct($piani) {
       $this->floor = $piani; 
   }
}

class Casa extends ProgettoEdificio {
   public $window; 

   public function __construct($piani, $finestre) {
     parent::__construct($piani); 
     $this->window = $finestre; 
   }
}

In questo modo, la classe Casa eredita le funzionalità di ProgettoEdificio, ma aggiunge anche le sue caratteristiche.