Detailed explanation of using delayed static binding in PHP

This time I will bring you a detailed explanation of the use of PHP delayed static binding. What are the precautions for using PHP delayed static binding? The following is a practical case, let's take a look.

The so-called delayed static binding, as the name suggests, When calling statically, the binding of the part on the left side of the :: symbol is delayed, which means that it is no longer parsed as the location where the current method is defined. class, but is calculated at 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 put It pulls 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, you need to start it. The keyboard starts 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 piece of bad code is eliminated.

It seems wrong

Run it, but found that the expected MySQL get() ## 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 originally wanted to bypass 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 usage of the

static keyword. For the example at the beginning of the article, you can change it like this:

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

Using late static binding, you will feel very relaxed when using PHP to implement

Design Pattern in 23.

I believe you have mastered the method after reading the case in this article. For more exciting information, please pay attention to other related articles on the php Chinese website!

Recommended reading:

Detailed explanation of the steps to implement guestbook based on object-oriented PHP

Usage of PHP Single Responsibility Principle (SRP) Case Analysis

The above is the detailed content of Detailed explanation of using delayed static binding in PHP. For more information, please follow other related articles on the PHP Chinese website!