La funzionalità denominata Type Hinting (informazioni sul tipo di classe o "suggerimento del tipo") è una tecnica introdotta con PHP 5, molto potente e flessibile, che ci permette di porre ulteriori regole nella programmazione orientata agli oggetti. Grazie al Type Hinting, possiamo specificare il tipo di oggetto passato, come parametro in una dichiarazione di funzione o di un metodo, facendo precedere il namespace dello stesso dal nome della classe desiderata.
Come è noto, PHP, è un linguaggio a "tipizzazione dinamica" (o debolmente tipizzato), in cui una variabile è in grado di cambiare il proprio tipo durante l'esecuzione del programma. Per questo motivo è possibile passare come parametri diversi tipi di dati. A tal proposito si analizzi il seguente esempio:
<?php
class Student {
public $name;
public function __construct($name){
$this->name = $name;
}
}
// la funzione accetta solo oggetti di tipo Student
// forza il passaggio del parametro ad essere istanza di Student
function infoStudent(Student $student) {
echo "Nome " . $student->name;
}
$obj_student = new Student("Giulia");
// stampa il valore della proprietà "name"...
$info = infoStudent($obj_student);
// genera un errore di tipo Catchable fatal error
$info = infoStudent("ciao");
?>La definizione del metodo infoStudent(), contiene il type hinting Student prima del parametro $student. Quindi, PHP, controllerà durante l'esecuzione dello script che gli argomenti siano del tipo specificato.
Nel caso in cui la funzione venga richiamata con un oggetto diverso da Student o un valore diverso da un oggetto, lo script terminerà visualizzando un errore di tipo Catchable fatal error, che ci indicherà che abbiamo passato un tipo di dato errato:
Catchable fatal error: Argument 1 passed to infoStudent() must be an instance of Student, string given, called in...Limitazioni del Type Hinting
In PHP, i tipi scalari, come stringhe e valori interi non sono supportati dal Type Hinting. Il seguente esempio genererà un errore di tipo Catchable fatal error poiché testHint non è vista come una stringa, ma come un'istanza della classe string
<?php
function testHint(string $string) {
echo $string;
}
testHint("Hello Html");
?>Nello specifico, l'esecuzione del codice proposto porterà alla produzione della seguente notifica:
Catchable fatal error: Argument 1 passed to testHint() must be an instance of string, string given, called in ...
Type Hinting e gerarchie
Il Type Hinting, non funziona solo ed esclusivamente con le classi indicate ma la sua valenza si espande anche alle varie sottoclassi. Ciò significa che se per esempio abbiamo una classe Cane che estende la classe Mammifero ed utilizziamo il Type Hinting Mammifero, possiamo passare anche un'istanza di tipo Cane:
<?php
// dichiarazione della classe Mammifero
class Mammifero {
public function speak(){
echo "";
}
}
// definizione della sottoclasse Cane
class Cane extends Mammifero {
public function speak(){
echo "Bau Bau";
}
}
function callSpeak(Mammifero $obj) {
echo $obj->speak();
}
$obj1 = new Cane();
// Stampa "Bau Bau"
callSpeak($obj1);
?>Infine, come ultimo tassello, possiamo utilizzare anche i namespace delle interfacce come Type Hinting: ogni classe che implementa un'interfaccia del tipo indicato, costituirà un parametro accettabile:
<?php
// definizione dell'interfaccia Forma
interface Person {
// costanti
const COSTANTE = "valore";
// definizione dei metodi
public function getName();
public function setName($name, $lastname);
}
class Student implements Person {
private $name = "";
private $lastname = "";
// implementazione dei metodi
public function getName(){
// corpo del Metodo
echo "<br />"."Person: "."$this->name $this->lastname";
}
public function setName($name, $lastname){
// corpo del Metodo
$this->name = $name;
$this->lastname = $lastname;
}
}
class Employee implements Person {
private $name = "";
private $lastname = "";
// implementazione dei metodi
public function getName(){
// corpo del Metodo
echo "<br />"."Employee: "."$this->name $this->lastname";
}
public function setName($name, $lastname){
// corpo del Metodo
$this->name = $name;
$this->lastname = $lastname;
}
}
// funzione test
function test(Person $obj) {
echo $obj->getName();
}
// istanze
$student = new Student();
$student->setName( "Giulia", "Q" );
$employee = new Employee();
$employee->setName( "Giuseppe", "Rossi" );
// Stampa "name"
test($student);
// Stampa "The name is name"
test($employee);
?>Il Type Hinting è è dunque uno strumento molto potente e flessibile che permette di porre ulteriori regole all'interno delle applicazioni OOP. Grazie ad esso è possibile avere un maggiore controllo sui parametri delle funzioni e dei metodi, rendendo gli script maggiormente robusti.