Les méthodes magiques sont des méthodes spéciales (préfixées par __) que PHP appelle automatiquement en réponse à certaines actions sur un objet — comme accéder à une propriété non définie, appeler une méthode non définie, ou convertir un objet en chaîne de caractères. Elles vous permettent de personnaliser le comportement des objets.
{
{ }
{ }
}
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 interceptent l'accès à des propriétés qui n'existent pas ou ne sont pas accessibles — permettant des propriétés dynamiques (utilisées par les ORMs, les objets de configuration).
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 interceptent les appels à des méthodes non définies — utilisées pour les APIs fluentes/dynamiques (par exemple le query builder de Laravel, les façades).
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
Les méthodes magiques sont une fonctionnalité importante de PHP pour personnaliser le comportement des objets, et les comprendre est utile à la fois pour les utiliser correctement et — notamment — pour comprendre comment les frameworks PHP réalisent leur « magie ». Des méthodes comme __get/__set (accès dynamique aux propriétés), __call/__callStatic (gestion dynamique de méthodes), __toString (conversion en chaîne), et __invoke (objets appelables) permettent aux objets de répondre intelligemment à des opérations qu'ils ne définissent pas explicitement.
C'est le mécanisme derrière beaucoup de la commodité des frameworks : Laravel Eloquent ORM utilise __get/__set pour les attributs de modèle, son query builder et ses façades utilisent __call/__callStatic pour les méthodes fluentes dynamiques, et les objets de configuration/collection les utilisent partout.
Reconnaître les méthodes magiques démystifie le fonctionnement de ces frameworks et vous permet de construire des APIs tout aussi flexibles.
Connaître les principales méthodes magiques, ce qui déclenche chacune, et leurs utilisations courantes dans les frameworks est une connaissance pratique pour à la fois écrire du PHP expressif et utiliser/étendre efficacement les frameworks construits sur ces dernières. (La mise en garde : les méthodes magiques peuvent affecter la clarté et le support des IDE — en abuser rend le code plus difficile à comprendre, donc elles sont mieux utilisées délibérément pour un vrai comportement dynamique, pas par défaut.)