详解PHP后期静态绑定分析与应用

男娘i 2022-04-23 16:44 169阅读 0赞

**参考经典文章：[https://www.jb51.net/article/136794.htm][https_www.jb51.net_article_136794.htm]**

**Static（静态）关键字**

作用：

> \- 在函数体内的修饰变量的static关键字用于定义静态局部变量。  
> \- 用于修饰类成员函数和成员变量时用于声明静态成员。  
> \- (PHP5.3之后)在作用域解析符(::)前又表示静态延迟绑定的特殊类。

例子：

定义静态局部变量（出现位置：局部函数中）

特征：静态变量仅在局部函数域中存在，但当程序执行离开此作用域时，其值并不丢失。

function test()
    {
     static $count = 0;
     
     $count++;
     echo $count;
     if ($count < 10) {
      test();
     }
     $count--;
     echo $count;
    }
    
    echo test();//123456789109876543210

定义静态方法，静态属性

a)声明类属性或方法为静态，就可以不实例化类而直接访问。

b)静态属性不能通过一个类已实例化的对象来访问（但静态方法可以）

c)如果没有指定访问控制，属性和方法默认为公有。

d)由于静态方法不需要通过对象即可调用，所以伪变量 $this 在静态方法中不可用。

e)静态属性不可以由对象通过 -> 操作符来访问。

f)用静态方式调用一个非静态方法会导致一个 E\_STRICT 级别的错误。

g)就像其它所有的 PHP 静态变量一样，静态属性只能被初始化为文字或常量，不能使用表达式。所以可以把静态属性初始化为整数或数组，但不能初始化为另一个变量或函数返回值，也不能指向一个对象。

a.静态方法例子（出现位置： 类的方法定义）

class Foo {
     public static function aStaticMethod() {
      // ...
     }
    }
     
    Foo::aStaticMethod();
    $classname = 'Foo';
    $classname::aStaticMethod(); // 自PHP 5.3.0后，可以通过变量引用类

b.静态属性例子（出现位置：类的属性定义）

class Foo
    {
     public static $my_static = 'foo';
     
     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
     
    $foo = new Foo();
    print $foo->staticValue() . "\n";//foo
    print $foo->my_static . "\n";  // Accessing static property Foo::$my_static as non static  静态属性
    //不能通过一个类已实例化的对象来访问（但静态方法可以）
     
    print $foo::$my_static . "\n";//foo
    $classname = 'Foo';
    print $classname::$my_static . "\n"; // As of PHP 5.3.0//foo
     
    print Bar::$my_static . "\n";//foo
    $bar = new Bar();
    print $bar->fooStatic() . "\n";//foo

c.用于后期静态绑定（出现位置： 类的方法中，用于修饰变量或方法）

下面详细分析

后期静态绑定（late static binding）

自 PHP 5.3.0 起，PHP 增加了一个叫做后期静态绑定的功能，用于在继承范围内引用静态调用的类。

**1.转发调用与非转发调用**

转发调用 :

指的是通过以下几种方式进行的静态调用：self::，parent::，static:: 以及 forward\_static\_call()。

非转发调用 ：

明确指定类名的静态调用（例如Foo::foo()）

非静态调用（例如$foo->foo()）

**2.后期静态绑定工作原理**

原理：存储了在上一个“非转发调用”（non-forwarding call）中的类名。意思是当我们调用一个转发调用的静态调用时，实际调用的类是上一个非转发调用的类。

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.更多静态后期静态绑定的例子**

**a)Self, Parent 和 Static的对比**

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";//Mango 
    echo $apple->parentname() . "\n";//Orange 
    echo $apple->staticname();//Apple

b)使用forward\_static\_call()

c)使用get\_called\_class()

**应用**

前面已经提到过了，引入后期静态绑定的目的是：用于在继承范围内引用静态调用的类。  
所以， 可以用后期静态绑定的办法解决单例继承问题。

先看一下使用self是一个什么样的情况：

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

通过上面的例子可以看到，使用self，实例化得到的都是类A的同一个对象

再来看看使用static会得到什么样的结果

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

可以看到，使用static可以解决self时出现的单例继承问题。

[https_www.jb51.net_article_136794.htm]: https://www.jb51.net/article/136794.htm