La liaison statique tardive contrôle quelle classe est référencée dans les contextes statiques au sein de l'héritage. La distinction clé : self:: fait référence à la classe où le code est écrit, tandis que static:: fait référence à la classe qui a été réellement — ce qui importe quand une classe enfant hérite d'une méthode statique d'une classe parent.
<?php
class ParentClass {
public static function create(): self {
return new self(); // self:: ALWAYS means ParentClass (where it's written)
}
public static function createStatic(): static {
return new static(); // static:: means the CALLED class (runtime)
}
}
class ChildClass extends ParentClass {}
get_class(ChildClass::create()); // "ParentClass" — self:: bound to where written ❌
get_class(ChildClass::createStatic()); // "ChildClass" — static:: bound to the call ✅
self:: est résolu au moment de la définition (toujours la classe de définition), donc même quand elle est appelée via ChildClass, new self() crée une ParentClass. static:: est résolu au runtime sur la classe réellement appelée — donc new static() crée correctement une ChildClass.
class Model {
public static function make(): static { // static return type + new static()
return new static(); // ✅ returns an instance of whatever subclass called it
}
}
class User extends Model {}
class Post extends Model {}
User::make(); // returns a User (not a Model) — thanks to late static binding
Post::make(); // returns a Post
La liaison statique tardive est ce qui rend les méthodes factory héritées, les constructeurs fluents et les motifs ORM retournant l'instance de la bonne sous-classe — essentiel pour les APIs basées sur les méthodes statiques dont dépendent les frameworks.
self:: → the class where the code is WRITTEN (early/static binding)
static:: → the class CALLED at runtime (late static binding) — for subclass-aware code
parent:: → the parent class (for calling overridden parent methods)
La liaison statique tardive (static:: vs `self::``) est un concept PHP important et souvent mal compris, particulièrement pertinent pour comprendre comment les frameworks implémentent les APIs statiques basées sur l'héritage.
La distinction cruciale — que self:: se lie à la classe où le code est écrit tandis que static:: se lie à la classe réellement appelée au runtime — importe chaque fois qu'une classe enfant hérite d'une méthode statique d'une classe parent qui crée des instances ou référence la classe : avec self::, les méthodes factory héritées retourneraient toujours le type parent (un bug), tandis que static:: retourne correctement la sous-classe appelée.
C'est exactement ce qui active les méthodes factory héritées, les constructeurs fluents et les motifs ORM sur lesquels dépendent les frameworks comme Eloquent de Laravel (ex. User::make() retournant un User, pas le Model de base).
Comprendre la liaison statique tardive est important à la fois pour utiliser correctement ces motifs de framework et pour écrire vos propres méthodes statiques conscientes de l'héritage qui se comportent correctement avec les sous-classes.
Bien que sujet plus avancé, c'est une source courante de bugs subtils et de confusion (« pourquoi cela retourne-t-il la classe parent ? »), et comprendre la distinction self::/static::/parent:: reflète une connaissance plus profonde du modèle objet de PHP et du comportement d'héritage — précieux pour travailler avec et construire les APIs basées sur les méthodes statiques et lourdes en héritage communes dans les frameworks PHP modernes.