Explication détaillée de la définition et exemples d'utilisation de la liaison post-statique PHP

Texte original du manuel : Depuis PHP 5.3.0, PHP a ajouté une fonctionnalité appelée liaison statique tardive, pour référence dans le cadre de l'héritage. qui sont appelés statiquement.

Le principe de fonctionnement de la liaison statique tardive est de stocker le nom de classe du précédent "appel sans transfert". Lors d'un appel de méthode statique, le nom de la classe est celui explicitement spécifié (généralement sur le côté gauche de l'opérateur :: lors d'un appel de méthode non statique, il s'agit de la classe à laquelle appartient l'objet) ; Ce que l'on appelle « appel de transfert » fait référence aux appels statiques effectués des manières suivantes : self::, parent::, static:: et forward_static_call(). Vous pouvez utiliser la fonction get_call_class() pour obtenir le nom de classe de la méthode appelée, et static :: indique sa portée.

Cette fonctionnalité est appelée « liaison statique tardive » d'un point de vue interne au langage. « Liaison tardive » signifie que static :: n'est plus résolu en classe dans laquelle la méthode actuelle est définie, mais est calculé au moment de l'exécution réelle. Elle peut également être appelée « liaison statique » car elle peut être utilisée pour (mais sans s’y limiter) des appels à des méthodes statiques.

Limitations de self::

Utilisez self:: ou __CLASS__ pour une référence statique à la classe actuelle, selon la classe dans laquelle la méthode actuelle est définie :

Exemple n°1 soi : Utilisation

<?php
class A {
public static function who() {
echo __CLASS__;
}
public static function test() {
self::who();
}
}
class B extends A {
public static function who() {
echo __CLASS__;
}
}
B::test();
?>

La routine ci-dessus affichera :

A

liaison statique tardive L'utilisation de la liaison statique tardive visait à contourner la limitation en introduisant un nouveau mot-clé représentant la classe initialement appelée par le runtime. En termes simples, ce mot-clé vous permet de faire référence à la classe B au lieu de A lors de l'appel de test() dans l'exemple ci-dessus. Il a finalement été décidé de ne pas introduire de nouveaux mots-clés, mais d'utiliser le mot-clé statique déjà réservé.

Exemple n°2 statique : Utilisation simple

<?php
class A {
public static function who() {
echo __CLASS__;
}
public static function test() {
static::who(); // 后期静态绑定从这里开始
}
}
class B extends A {
public static function who() {
echo __CLASS__;
}
}
B::test();
?>

La routine ci-dessus affichera :

B

Remarque : Dans un environnement non statique, la classe appelée est la classe à laquelle appartient l'instance d'objet. Puisque $this-> tentera d'appeler la méthode privée dans la même portée, static:: peut donner des résultats différents. Une autre différence est que static:: ne peut être utilisé qu'avec des propriétés statiques.

Exemple n°3 Utilisation de static ::

<?php
class A {
private function foo() {
echo "success!\n";
}
public function test() {
$this->foo();
static::foo();
}
}
class B extends A {
/* foo() will be copied to B, hence its scope will still be A and
* the call be successful */
}
class C extends A {
private function foo() {
/* original method is replaced; the scope of the new one is C */
}
}
$b = new B();
$b->test();
$c = new C();
$c->test(); //fails
?>

dans un environnement non statique La routine ci-dessus affichera :

succès !
succès !
succès !
Erreur fatale : appel à la méthode privée C::foo() depuis le contexte 'A' dans /tmp/test.php à la ligne 9

Remarque : La résolution de liaison statique tardive se poursuit jusqu'à ce qu'un appel statique entièrement résolu soit obtenu. D'un autre côté, s'il est appelé de manière statique à l'aide de parent:: ou self::, les informations d'appel seront transmises.

Exemple n°4 : Renvoi et non-renvoi d'appels

<?php
class A {
public static function foo() {
static::who();
}
public static function who() {
echo __CLASS__."\n";
}
}
class B extends A {
public static function test() {
A::foo();
parent::foo();
self::foo();
}
public static function who() {
echo __CLASS__."\n";
}
}
class C extends B {
public static function who() {
echo __CLASS__."\n";
}
}
C::test();
?>

La routine ci-dessus affichera :

A
C
C

L'exemple suivant analyse une classe qui fait référence aux appels statiques dans la portée de l'héritage en fonction de la fonction de liaison statique tardive de PHP.

Regardez d'abord le code suivant :

class Person
{
public static function status()
{
self::getStatus();
}
protected static function getStatus()
{
echo "Person is alive";
}
}
class Deceased extends Person
{
protected static function getStatus()
{
echo "Person is deceased";
}
}
Deceased::status(); //Person is alive

Évidemment, le résultat n'est pas celui attendu. C'est parce que self:: dépend de l'endroit où. c'est la classe définie, pas la classe en cours d'exécution. Afin de résoudre ce problème, vous pouvez remplacer la méthode status() dans la classe héritée. Une meilleure solution est que PHP 5.3 ajoute la fonction de liaison statique tardive.

Le code est le suivant :

class Person
{
public static function status()
{
static::getStatus();
}
protected static function getStatus()
{
echo "Person is alive";
}
}
class Deceased extends Person
{
protected static function getStatus()
{
echo "Person is deceased";
}
}
Deceased::status(); //Person is deceased

On voit que static:: ne pointe plus vers la classe actuelle. En fait, elle. est calculé pendant le fonctionnement. Force l'obtention de toutes les propriétés de la classe finale.

Par conséquent, il est recommandé de ne pas utiliser self:: à l'avenir et d'utiliser static ::

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!