Explication détaillée de l'utilisation de la liaison statique retardée en PHP

Cette fois, je vais vous apporter une explication détaillée de l'utilisation de la liaison statique retardée PHP. Quelles sont les précautions à prendre pour utiliser la liaison statique retardée PHP ? Voici un cas pratique, jetons un coup d'oeil.

La liaison statique dite retardée, comme son nom l'indique, lorsque appelle statiquement , la liaison de la partie sur le côté gauche du symbole :: est retardée, ce qui signifie qu'elle n'est plus analysé comme l'emplacement où la classe de la méthode actuelle est définie, mais est calculé au moment de l'exécution réelle. Cet article présente principalement le contenu pertinent sur la liaison statique retardée PHP. Je ne dirai pas grand-chose ci-dessous, jetons un coup d'œil à l'introduction détaillée.

Je sens quelque chose de mauvais

Je regardais le code PHP en arrière-plan du projet pendant cette période et j'ai vu un morceau de code semblable à ce qui suit. Il sort :

<?php
 class DBHandler {
  function get() {}
 }
 class MySQLHandler extends DBHandler {
  // 这里一个create
  public static function create() {
   echo "MySQL";
   return new self();
  }
  public function get() {
   echo "MySQL get()";
  }
 }
 class MemcachedHandler extends DBHandler {
  // 这里又有一个create
  public static function create() {
   echo "Memcached";
   return new self();
  }
  public function get() {
   echo "Memcached get";
  }
 }
 function get(DBHandler $handler) {
  $handler->get();
 }
 $dbHandler = MySQLHandler::create();
 get($dbHandler);
?>

Est-ce que vous sentez un mauvais code ? Comme vous pouvez le voir, il existe une fonction de création dans les classes MySQLHandler et MemcachedHandler. Après avoir supprimé mes instructions de sortie, j'ai constaté qu'elles étaient exactement les mêmes. Il s'agit d'une redondance de code. Oui, une refactorisation du code est requise.

Réaliser un refactoring simple

Le refactoring de code est partout, tant que vous y réfléchissez et que vous sentez qu'il y a une amélioration, vous devez démarrez-le Le clavier commence à fonctionner. Allez, refactorisez le code ci-dessus comme suit :

<?php
 class DBHandler {
  public static function create() {
   echo "create";
   return new self();
  }
  function get() {}
 }
 class MySQLHandler extends DBHandler {
  public function get() {
   echo "MySQL get()";
  }
 }
 class MemcachedHandler extends DBHandler {
  public function get() {
   echo "Memcached get";
  }
 }
 function get(DBHandler $handler) {
  $handler->get();
 }
 $dbHandler = MySQLHandler::create();
 get($dbHandler);
?>

Déplacez la fonction de création dans la classe DBHandler Cela a l'air bien, au moins un morceau de mauvais code en moins est éliminé.

Cela semble faux

Exécutez-le, mais vous constatez que le MySQL get() auquel nous nous attendions n'est pas imprimé. Que se passe-t-il? Cela montre que la fonction get de MySQLHandler n'est pas appelée, mais le code l'appelle clairement. Cela montre qu'il y a un problème avec le code new self() . Qu'est-ce qui ne va pas avec ça ? Cela nous amène au point central du résumé d’aujourd’hui : la liaison statique retardée.

Liaison statique retardée

La liaison statique retardée a été introduite après PHP5.3. Regardez à nouveau le code suivant :

<?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();
?>

Le code ci-dessus génère A, mais je veux qu'il génère B. C'est le problème. C'est aussi une limitation de soi et de la CLASSE. Une référence statique à la classe actuelle utilisant self:: ou CLASS, selon la classe dans laquelle la méthode actuelle est définie. Cela explique donc très bien pourquoi le code ci-dessus génère A. Mais que se passe-t-il si nous devons produire B ? Vous pouvez faire ceci :

<?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 liaison statique tardive est destinée à contourner la restriction en introduisant un nouveau mot-clé pour représenter la classe initialement appelée au moment de l'exécution. 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é.

C'est la racine de la liaison statique tardive ——une utilisation alternative du mot-clé statique . Pour l'exemple au début de l'article, vous pouvez le modifier comme ceci :

return new static(); // 改变这里，后期静态绑定

En utilisant la liaison statique tardive, vous vous sentirez très détendu lorsque vous utiliserez PHP pour implémenter le modèle de conception dans 23 de.

Je pense que vous maîtrisez la méthode après avoir lu le cas dans cet article. Pour des informations plus intéressantes, veuillez prêter attention aux autres articles connexes sur le site Web chinois de php !

Lecture recommandée :

Explication détaillée des étapes de mise en œuvre du livre d'or basé sur PHP orienté objet

Utilisation de PHP Single Analyse de cas du principe de responsabilité (SRP)

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!