Detailed explanation of PHP late static binding analysis and application

This article summarizes the relevant knowledge points of PHP late static binding analysis and application. Friends who are interested in this can learn it.

Basic knowledge

1. Range parsing operator (::)

• can be used to access static members, class constants, and can also be used to override properties and methods in the class.

• The three special keywords self, parent and static are used to access its properties or methods inside the class definition.

• parent is used to call overridden properties or methods in the parent class (where it appears, it will be resolved to the parent class of the corresponding class).

• self is used to call methods or properties in this class (wherever it appears, it will be parsed into the corresponding class; note the difference with $this, $this points to the currently instantiated object ).

• When a subclass overrides a method in its parent class, PHP will not call the overridden method in the parent class. Whether the method of the parent class is called depends on the child class.
  

2. The PHP kernel places the inheritance implementation of classes in the "compilation phase"

<?php
class A{
 const H = &#39;A&#39;;

 const J = &#39;A&#39;;

 static function testSelf(){
  echo self::H; //在编译阶段就确定了 self解析为 A
 }
}

class B extends A{
 const H = "B";

 const J = &#39;B&#39;;

 static function testParent(){
  echo parent::J; //在编译阶段就确定了 parent解析为A
 }

 /* 若重写testSelf则能输出“B”, 且C::testSelf()也是输出“B”
 static function testSelf(){
  echo self::H;
 }
 */

}

class C extends B{
 const H = "C";

 const J = &#39;C&#39;;
}

B::testParent();
B::testSelf();

echo "\n";

C::testParent();
C::testSelf();

Running result:

AA
AA

##Conclusion:

self::and parent:: appears in the definition of a certain class X, it will be resolved to the corresponding class X, unless the method of the parent class is overridden in the subclass.

3.Static (static) keyword

Function:

- The static keyword is used to modify variables in the function body Define static local variables.

- Used to declare static members when modifying class member functions and member variables.
- (After PHP5.3) A special class that represents static delayed binding before the scope resolver (::).

Example:

Define static local variables (position: in local functions)

Features: Static variables only exist in the local function domain, but when the program Its value is not lost when execution leaves this scope.

<?php
function test()
{
 static $count = 0;

 $count++;
 echo $count;
 if ($count < 10) {
  test();
 }
 $count--;
}

Define static methods, static attributes

a) Declare class attributes or methods as static, you do not need to instantiate the class And direct access.

b) Static properties cannot be accessed through an instantiated object of a class (but static methods can)

c) If access control is not specified, properties and methods Default is public.

d) Since static methods do not require an object to be called, the pseudo variable $this is not available in static methods.

e) Static properties cannot be accessed by objects through the -> operator.

f) Calling a non-static method statically will result in an E_STRICT level error.

g) Like all other PHP static variables, static properties can only be initialized to literals or constants, not expressions. So a static property can be initialized to an integer or an array, but it cannot be initialized to another variable or function return value, nor can it point to an object.

a. Static method example (appears in: class method definition)

<?php
class Foo {
 public static function aStaticMethod() {
  // ...
 }
}

Foo::aStaticMethod();
$classname = &#39;Foo&#39;;
$classname::aStaticMethod(); // 自PHP 5.3.0后，可以通过变量引用类
?>

b. Static attribute example (appears in: class Attribute definition)

<?php
class Foo
{
 public static $my_static = &#39;foo&#39;;

 public function staticValue() {
  return self::$my_static; //self 即 FOO类
 }
}

class Bar extends Foo
{
 public function fooStatic() {
  return parent::$my_static; //parent 即 FOO类
 }
}

print Foo::$my_static . "\n";

$foo = new Foo();
print $foo->staticValue() . "\n";
print $foo->my_static . "\n";  // Undefined "Property" my_static 

print $foo::$my_static . "\n";
$classname = &#39;Foo&#39;;
print $classname::$my_static . "\n"; // As of PHP 5.3.0

print Bar::$my_static . "\n";
$bar = new Bar();
print $bar->fooStatic() . "\n";
?>

c. Used for late static binding (appearance: in the method of the class, used to modify variables or methods)

Detailed analysis below

Late static binding

Since PHP 5.3.0, PHP has added a feature called The function of late static binding is used to reference statically called classes in the inheritance scope.

1. Forwarded calls and non-forwarded calls

Forwarded calls:

refers to static calls made in the following ways :self::, parent::, static:: and forward_static_call().

Non-forwarded calls:

Static calls that explicitly specify the class name (e.g. Foo::foo())

Non-static calls (e.g. $ foo->foo())

2. Working principle of late static binding

Principle: Store the previous "non-forwarded" Class name in non-forwarding call. This means that when we call a static call that is a forward call, the class actually called is the class of the previous non-forward call.

Example analysis:

<?php
class A {
 public static function foo() {
  echo __CLASS__."\n";
  static::who();
 }

 public static function who() {
  echo __CLASS__."\n";
 }
}

class B extends A {
 public static function test() {
  echo "A::foo()\n";
  A::foo();
  echo "parent::foo()\n";
  parent::foo();
  echo "self::foo()\n";
  self::foo();
 }

 public static function who() {
  echo __CLASS__."\n";
 }
}

class C extends B {
 public static function who() {
  echo __CLASS__."\n";
 }
}

C::test();

/*
 * C::test(); //非转发调用 ，进入test()调用后，“上一次非转发调用”存储的类名为C
 *
 * //当前的“上一次非转发调用”存储的类名为C
 * public static function test() {
 *  A::foo(); //非转发调用， 进入foo()调用后，“上一次非转发调用”存储的类名为A，然后实际执行代码A::foo(), 转 0-0
 *  parent::foo(); //转发调用， 进入foo()调用后，“上一次非转发调用”存储的类名为C， 此处的parent解析为A ,转1-0
 *  self::foo(); //转发调用， 进入foo()调用后，“上一次非转发调用”存储的类名为C， 此处self解析为B, 转2-0
 * }
 *
 *
 * 0-0
 * //当前的“上一次非转发调用”存储的类名为A
 * public static function foo() {
 *  static::who(); //转发调用， 因为当前的“上一次非转发调用”存储的类名为A， 故实际执行代码A::who(),即static代表A，进入who()调用后，“上一次非转发调用”存储的类名依然为A，因此打印 “A”
 * }
 *
 * 1-0
 * //当前的“上一次非转发调用”存储的类名为C
 * public static function foo() {
 *  static::who(); //转发调用， 因为当前的“上一次非转发调用”存储的类名为C， 故实际执行代码C::who(),即static代表C，进入who()调用后，“上一次非转发调用”存储的类名依然为C，因此打印 “C”

 * }
 *
 * 2-0
 * //当前的“上一次非转发调用”存储的类名为C
 * public static function foo() {
 *  static::who(); //转发调用， 因为当前的“上一次非转发调用”存储的类名为C， 故实际执行代码C::who(),即static代表C，进入who()调用后，“上一次非转发调用”存储的类名依然为C，因此打印 “C”
 * }
 */


故最终结果为：
A::foo()
A
A
parent::foo()
A
C
self::foo()
A
C

3. More examples of static late static binding

a) Comparison of Self, Parent and Static

<?php
class Mango {
 function classname(){
  return __CLASS__;
 }

 function selfname(){
  return self::classname();
 }

 function staticname(){
  return static::classname();
 }
}

class Orange extends Mango {
 function parentname(){
  return parent::classname();
 }

 function classname(){
  return __CLASS__;
 }
}

class Apple extends Orange {
 function parentname(){
  return parent::classname();
 }

 function classname(){
  return __CLASS__;
 }
}

$apple = new Apple();
echo $apple->selfname() . "\n";
echo $apple->parentname() . "\n";
echo $apple->staticname();

?>

运行结果：
Mango
Orange
Apple

b) Using forward_static_call()

<?php
class Mango
{
 const NAME = &#39;Mango is&#39;;
 public static function fruit() {
  $args = func_get_args();
  echo static::NAME, " " . join(&#39; &#39;, $args) . "\n";
 }
}

class Orange extends Mango
{
 const NAME = &#39;Orange is&#39;;

 public static function fruit() {
  echo self::NAME, "\n";

  forward_static_call(array(&#39;Mango&#39;, &#39;fruit&#39;), &#39;my&#39;, &#39;favorite&#39;, &#39;fruit&#39;);
  forward_static_call(&#39;fruit&#39;, &#39;my&#39;, &#39;father\&#39;s&#39;, &#39;favorite&#39;, &#39;fruit&#39;);
 }
}

Orange::fruit(&#39;NO&#39;);

function fruit() {
 $args = func_get_args();
 echo "Apple is " . join(&#39; &#39;, $args). "\n";
}

?>


运行结果：
Orange is
Orange is my favorite fruit
Apple is my father&#39;s favorite fruit

c) Use get_called_class()

<?php


class Mango {
 static public function fruit() {
  echo get_called_class() . "\n";
 }
}

class Orange extends Mango {
 //
}

Mango::fruit();
Orange::fruit();

?>



运行结果：
Mango
Orange

Application

Already done before As mentioned before, the purpose of introducing late static binding is to reference statically called classes in the inheritance scope.

So, you can use late static binding to solve the singleton inheritance problem.

Let’s first look at what it is like to use self:

<?php
// new self 得到的单例都为A。
class A
{
 protected static $_instance = null;

 protected function __construct()
 {
  //disallow new instance
 }

 protected function __clone(){
  //disallow clone
 }

 static public function getInstance()
 {
  if (self::$_instance === null) {
   self::$_instance = new self();
  }
  return self::$_instance;
 }
}

class B extends A
{
 protected static $_instance = null;
}

class C extends A{
 protected static $_instance = null;
}

$a = A::getInstance();
$b = B::getInstance();
$c = C::getInstance();

var_dump($a);
var_dump($b);
var_dump($c);




运行结果：
E:\code\php_test\apply\self.php:37:
class A#1 (0) {
}
E:\code\php_test\apply\self.php:38:
class A#1 (0) {
}
E:\code\php_test\apply\self.php:39:
class A#1 (0) {
}

As you can see from the above example, use self to instantiate All we get are the same objects of class A

Let’s see what kind of results will be obtained by using static

<?php
// new static 得到的单例分别为D，E和F。
class D
{
 protected static $_instance = null;

 protected function __construct(){}
 protected function __clone()
 {
  //disallow clone
 }

 static public function getInstance()
 {
  if (static::$_instance === null) {
   static::$_instance = new static();
  }
  return static::$_instance;
 }
}

class E extends D
{
 protected static $_instance = null;
}

class F extends D{
 protected static $_instance = null;
}

$d = D::getInstance();
$e = E::getInstance();
$f = F::getInstance();

var_dump($d);
var_dump($e);
var_dump($f);




运行结果：
E:\code\php_test\apply\static.php:35:
class D#1 (0) {
}
E:\code\php_test\apply\static.php:36:
class E#2 (0) {
}
E:\code\php_test\apply\static.php:37:
class F#3 (0) {
}

The above is what I compiled For everyone, I hope it will be helpful to everyone in the future.

related articles:

AjaxSubmit() submits the file file

Two methods for Ajax to solve redundant refreshes

A brief analysis and solutions to Ajax synchronization and asynchronous issues

The above is the detailed content of Detailed explanation of PHP late static binding analysis and application. For more information, please follow other related articles on the PHP Chinese website!