I magic methods sono metodi speciali (prefissati con __) che PHP chiama automaticamente in risposta a determinate azioni su un oggetto — come accedere a una proprietà non definita, chiamare un metodo non definito, o convertire un oggetto in stringa. Ti permettono di agganciarti e personalizzare il comportamento degli oggetti.
{
{ }
{ }
}
class Container {
private array $data = [];
public function __get($name) { // called on reading an INACCESSIBLE/undefined property
return $this->data[$name] ?? null;
}
public function __set($name, $value) { // called on writing one
$this->data[$name] = $value;
}
public function __isset($name): bool { return isset($this->data[$name]); }
}
$c = new Container();
$c->foo = "bar"; // triggers __set('foo', 'bar')
echo $c->foo; // triggers __get('foo') → "bar"
__get/__set intercettano l'accesso a proprietà che non esistono o non sono accessibili — abilitando proprietà dinamiche (utilizzate da ORM, oggetti di configurazione).
class Api {
public function __call($method, $args) { // called for UNDEFINED method calls
return $this->request($method, $args); // e.g. dynamic API methods
}
public static function __callStatic($method, $args) { /* static version */ }
}
$api->getUsers(); // no getUsers() method → __call('getUsers', [])
__call/__callStatic intercettano le chiamate a metodi non definiti — utilizzati per API fluide/dinamiche (ad es. il query builder di Laravel, facades).
class Money {
public function __construct(private float $amount) {}
public function __toString(): string { // when the object is used as a string
return '$' . number_format($this->amount, 2);
}
}
echo new Money(9.5); // "$9.50" — __toString called automatically
class Multiplier {
public function __invoke($x) { return $x * 2; } // makes the object CALLABLE
}
$double = new Multiplier();
$double(5); // 10 — __invoke called
I magic methods sono una caratteristica importante di PHP per personalizzare il comportamento degli oggetti, e comprenderli è prezioso sia per usarli in modo appropriato che — soprattutto — per capire come i framework PHP ottengono la loro "magia". Metodi come __get/__set (accesso dinamico alle proprietà), __call/__callStatic (gestione dinamica dei metodi), __toString (conversione a stringa), e __invoke (oggetti callable) permettono agli oggetti di rispondere in modo intelligente a operazioni che non definiscono esplicitamente.
Questo è il meccanismo dietro molti dei vantaggi dei framework: Eloquent ORM di Laravel usa __get/__set per gli attributi del modello, il suo query builder e le facades usano __call/__callStatic per metodi dinamici fluidi, e gli oggetti di configurazione/collezione li usano in tutta l'applicazione.
Riconoscere i magic methods demistifica il funzionamento di questi framework e ti permette di costruire API altrettanto flessibili.
Conoscere i magic methods principali, cosa attiva ognuno, e i loro utilizzi comuni nei framework è una conoscenza pratica sia per scrivere PHP espressivo che per utilizzare/estendere efficacemente i framework costruiti su di essi. (L'avvertenza: i magic methods possono ridurre la chiarezza e il supporto dell'IDE — abusarne rende il codice più difficile da capire, quindi è meglio usarli deliberatamente per un autentico comportamento dinamico, non come default.)