liaison tardive php

Le contenu de cet article est post-reliure PHP. Maintenant, je le partage avec tout le monde. Les amis dans le besoin peuvent également se référer à cet article

reliure post-statique PHP.

Depuis PHP 5.3.0, PHP a ajouté une fonctionnalité appelée liaison statique tardive, qui est utilisée pour référencer

classes appelées statiquement dans la portée de l'héritage.

Pour être précis, le principe de fonctionnement de la liaison statique tardive est de stocker les données dans le précédent "appel sans transfert" (sans transfert
appel) nom de la classe. Lors d'un appel de méthode statique, le nom de la classe est celui explicitement spécifié (généralement dans ::
opérateur) ; lors d’un appel de méthode non statique, il s’agit de la classe à laquelle appartient l’objet. Ce qu'on appelle le « renvoi d'appel » (renvoi
call) fait référence aux appels statiques via les méthodes 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, static ::
souligne sa portée.

Cette fonctionnalité est nommée "Late Static Binding" d'un point de vue interne au langage. "Reliure tardive" signifie statique ::
n'est plus analysé dans la classe dans laquelle la méthode actuelle est définie, mais est calculé pendant 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.

self

Utilisez self:: ou CLASS une référence statique à la classe actuelle, selon l'endroit où se trouve le courant méthode est définie Classe :

Exemple n°1 self:: Utilisation

<?phpclass 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(); //输出A?>

staticUsage d'une liaison statique tardive

La liaison statique tardive était destinée à être effectuée en introduisant un nouveau Le mot clé représente la classe que le runtime appelle initialement pour contourner la restriction. 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é.

<?phpclass 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();  //输出B?>

Remarque :

Dans un environnement non statique, la classe appelée est la classe à laquelle appartient l'instance d'objet. Puisque $this-> essaiera d'appeler la méthode privée dans la même portée, tandis que 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.

Utilisez static ::

<?phpclass 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 :

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 la liaison statique tardive se poursuivra 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.

Renvoi et non-renvoi d'appels

<?phpclass 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

Recommandations associées :

Liaison tardive en PHP

Pensez au problème de la liaison tardive php

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!