An in-depth look at PHP delayed static binding

This article mainly introduces you to the relevant information about PHP delayed static binding. I will share it with you here. Friends in need can refer to it

Preface

The so-called delayed static binding, as the name implies, when calling statically, the binding of the part on the left side of the :: symbol is delayed, that is to say, it is no longer parsed into the class in which the current method is defined, but Calculated during actual runtime. This article mainly introduces the relevant content about PHP delayed static binding. I won’t say much below, let’s take a look at the detailed introduction.

I smell something bad

During this period, I looked at the PHP code in the background of the project and saw a piece of code similar to the following , I pulled it out:

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

Do you smell bad code? As you can see, there is a create function in the MySQLHandler and MemcachedHandler classes. After removing my output statements, I found that they are exactly the same. This is code redundancy. Yes, code refactoring is required.

Carry out simple refactoring

Code refactoring is everywhere, as long as you think about it and you feel there is improvement, just You need to hit the keyboard and start working. Come on, refactor the above code as follows:

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

Move the create function into the DBHandler class, it looks good, at least one less That bad code.

It seems wrong

Run it, but found that the MySQL get( we expected was not printed out ) . what's the situation? This shows that the get function of MySQLHandler was not called, but the code clearly called it. This shows that there is a problem with the code new self() . What's wrong with this? This brings us to the focus of today’s summary—delayed static binding.

Delayed static binding

Delayed static binding was introduced after PHP5.3. Look at the following code again:

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

The above code outputs A, but I want it to output B. This is the problem. This is also a limitation of self and __CLASS__. A static reference to the current class using self:: or __CLASS__, depending on the class in which the current method is defined. So, this explains very well why the above code outputs A. But what if we need to output B? You can do this:

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

Late static binding was originally intended to circumvent the restriction by introducing a new keyword to represent the class initially called at runtime. Simply put, this keyword allows you to refer to class B instead of A when calling test() in the above example. It was finally decided not to introduce new keywords, but to use the already reserved static keyword.

This is the root of late static binding - an alternative use of the static keyword. For the example at the beginning of the article, you can change it like this:

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

This kind of use of late static binding, when using PHP to implement the 23 design patterns, you You will feel very relaxed.

Summary

is a very simple knowledge point, but it is very useful. To sum up, I checked some information. Add some knowledge points. Review the past and learn the new. Okay, I hope it helps everyone. If you have any suggestions to make my articles better, feel free to ask them, I need your help.

Related recommendations:

PHP delayed static binding static detailed explanation

php implements late static binding

The above is the detailed content of An in-depth look at PHP delayed static binding. For more information, please follow other related articles on the PHP Chinese website!