PHP implémente une fonctionnalité appelée late static binding, en français la résolution statique à la volée, qui peut être utilisée pour référencer la classe appelée dans un contexte d'héritage statique.
Plus précisément, les résolutions statiques à la volée fonctionnent en enregistrant le nom de la classe dans le dernier "appel non transmis". Dans le cas des appels de méthodes statiques, il s'agit de la classe explicitement nommée (généralement, celle à gauche de l'opérateur ::) ; dans le cas de méthodes non statiques, il s'agit de la classe de l'objet. Un "appel transmis" est un appel statique déclenché par self::, parent::, static::, ou, tout en haut de la hiérarchie des classes, forward_static_call(). La fonction get_called_class() peut être utilisée pour récupérer une chaine contenant le nom de la classe appelée, et static:: introduit son espace.
Cette fonctionnalité a été baptisée "late static bindings", avec un point de vue interne. "Late binding", littéralement résolution tardive, vient du fait que les éléments static:: ne seront pas résolus en utilisant la classe où la méthode a été définie, mais celle qui est active durant l'exécution. L'adjectif statique a été ajouté car ce problème s'applique (sans y être limité) aux méthodes statiques.
self:: Les références statiques à la classe courante, avec self:: ou __CLASS__, sont résolues en utilisant la classe à laquelle appartiennent les fonctions, celle où elles ont été définies :
Exemple #1 Utilisation de self::
<?php
class A {
public static function qui() {
echo __CLASS__;
}
public static function test() {
self::qui();
}
}
class B extends A {
public static function qui() {
echo __CLASS__;
}
}
B::test();
?>L'exemple ci-dessus va afficher :
A
La résolution statique à la volée essaie de dépasser cette limitation en introduisant un mot clé qui fait référence à la classe qui a été appelée durant l'exécution. Pour faire simple, ce mot-clé permet le référencement à B depuis test(), dans l'exemple précédent. Il a été décidé de ne pas introduire de nouveau mot clé, mais plutôt d'utiliser le mot static qui était déjà réservé.
Exemple #2 Utilisation simple de static::
<?php
class A {
public static function qui() {
echo __CLASS__;
}
public static function test() {
static::qui(); // Ici, résolution à la volée
}
}
class B extends A {
public static function qui() {
echo __CLASS__;
}
}
B::test();
?>L'exemple ci-dessus va afficher :
B
Note:
Dans les contextes non statiques, la classe appelée sera celle de l'objet. Comme
$this->essayera d'appeler des méthodes privées depuis le même contexte, utiliserstatic::pourrait donner des résultats différents. Notez aussi questatic::ne peut faire référence qu'à des attributs/méthodes statiques.
Exemple #3 Utilisation de static:: dans un contexte non statique
<?php
class A {
private function foo() {
echo "success!\n";
}
public function test() {
$this->foo();
static::foo();
}
}
class B extends A {
}
class C extends A {
private function foo() {
}
}
$b = new B();
$b->test();
$c = new C();
$c->test(); //échoue
?>L'exemple ci-dessus va afficher :
success! success! success! Fatal error: Call to private method C::foo() from context 'A' in /tmp/test.php on line 9
Note:
La résolution des statiques à la volée va s'arrêter à un appel statique complètement résolu. D'un autre coté, les appels statiques en utilisant un mot-clé comme
parent::ouself::vont transmettre l'information appelante.Exemple #4 Appel avec ou sans transmission
<?php
class A {
public static function foo() {
static::qui();
}
public static function qui() {
echo __CLASS__."\n";
}
}
class B extends A {
public static function test() {
A::foo();
parent::foo();
self::foo();
}
public static function qui() {
echo __CLASS__."\n";
}
}
class C extends B {
public static function qui() {
echo __CLASS__."\n";
}
}
C::test();
?>L'exemple ci-dessus va afficher :
A C C