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

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

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

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

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

Design Pattern in 23.

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!