Explication détaillée des différences entre les liaisons self, static, $this et late static en PHP-tutoriel php-php.cn

Le contenu partagé avec vous dans cet article concerne les différences entre self, static et $this en PHP et l'explication détaillée de la liaison statique tardive. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer

La différence entre self, static et $this

Afin de mieux comprendre la différence entre self, static et $this , regardons d'abord un exemple .

<?phpclass A {    protected $name = &#39;A&#39;;    static $alias = &#39;a&#39;;    const HASH = &#39;md5&#39;;    public function dd() {        echo $this->name; echo '--';        echo static::$alias; echo '--';     // 后期静态绑定
        echo static::HASH; echo '--';     // 后期静态绑定
        echo self::$alias; echo '--';        echo self::HASH; echo '--';

        var_dump(new self); echo '--';
        var_dump($this); echo '--';
        var_dump(new static); echo '<br>';   // 后期静态绑定
    }    public static function who() {        echo __CLASS__;        echo ' [ This is A ]'; echo '<br>';
    }    public static function test() {        self::who();
    }    public static function test2() {        static::who();  // 后期静态绑定
    }    public static function getInstance() {
        var_dump(new self); echo '--';
        var_dump(new static); echo '<br>';  // 后期静态绑定
    }
}class B extends A {    protected $name = 'B';    static $alias = 'b';    const HASH = 'sha1';    public static function who() {        echo __CLASS__;        echo ' [ This is B ]'; echo '<br>';
    }
}class C extends B {    public static function who() {        echo __CLASS__;        echo ' [ This is C]'; echo '<br>';
    }
}


(new A)->dd();  // A--a--md5--a--md5--object(A)#2 (1) { ["name":protected]=> string(1) "A" } --object(A)#1 (1) { ["name":protected]=> string(1) "A" } --object(A)#2 (1) { ["name":protected]=> string(1) "A" }(new B)->dd();  // B--b--sha1--a--md5--object(A)#2 (1) { ["name":protected]=> string(1) "A" } --object(B)#1 (1) { ["name":protected]=> string(1) "B" } --object(B)#2 (1) { ["name":protected]=> string(1) "B" }A::who();  // A [ This is A ]B::who();  // B [ This is B ]A::test();  // A [ This is A ]B::test();  // A [ This is A ]A::test2(); // A [ This is A ]B::test2(); // B [ This is B ]C::test2(); // C [ This is C]A::getInstance();   // object(A)#1 (1) { ["name":protected]=> string(1) "A" } --object(A)#1 (1) { ["name":protected]=> string(1) "A" }B::getInstance();   // object(A)#1 (1) { ["name":protected]=> string(1) "A" } --object(B)#1 (1) { ["name":protected]=> string(1) "B" }

Copier après la connexion

Résumé :

self et __CLASS__ sont des références statiques à la classe actuelle, selon l'endroit où la méthode actuelle est définie. En d’autres termes, la classe dans laquelle self est écrit sera celle à laquelle il fait référence.
$this pointe vers l'objet lorsqu'il est réellement appelé, c'est-à-dire que pendant le processus d'exécution réel, quiconque appelle les propriétés ou les méthodes de la classe, $this pointe vers la classe. objet. Mais $this ne peut pas accéder aux propriétés statiques et aux constantes de la classe, et $this ne peut pas exister dans les méthodes statiques.
En plus de déclarer les membres statiques (propriétés et méthodes) d'une classe, le mot-clé static joue également un rôle très important dans la liaison statique tardive.
self peut être utilisé pour accéder aux propriétés statiques, aux méthodes statiques et aux constantes d'une classe, mais self pointe vers la classe où elle est actuellement définie, ce qui est une limitation de self.
L'objet pointé par $this appartient à la même classe que la classe pointée par static.
static peut être utilisé dans des méthodes statiques ou non statiques, et peut également accéder aux propriétés statiques, aux méthodes statiques, aux constantes et aux méthodes non statiques de la classe, mais ne peut pas accéder aux méthodes non statiques. propriétés.
Lors d'un appel statique, static pointe vers la classe qui est réellement appelée ; lors d'un appel non statique, static pointe vers la classe à laquelle l'objet est réellement appelé.

Liaison statique tardive

La liaison statique tardive (également appelée liaison statique retardée) peut être utilisée pour référencer des classes appelées statiquement dans la portée de l'héritage, c'est-à-dire du code La classe qui est initialement appelé au moment de l'exécution.

La liaison statique ultérieure était initialement destinée à être exprimée en introduisant un nouveau mot-clé, mais à la fin, le mot-clé statique a été utilisé.

工作原理

确切地说，static 后期静态绑定的工作原理是存储了上一个非转发调用（non-forwarding call）的类名。

当进行静态方法调用时，该类名（static指向的类名）为明确指定的那个（通常是 :: 运算符的左侧部分），即实际调用时的类。

如上述示例中的：

A::test2(); B::test2();

Copier après la connexion

static 和 self 的区别：

self 可以用于访问类的静态属性、静态方法和常量，但 self 指向的是当前定义所在的类，这是 self 的限制。
static 也可以用于访问类的静态属性、静态方法和常量，static 指向的是实际调用时的类。

当进行非静态方法调用时，该类名（static指向的类名）为该对象所属的类，即实际调用时的对象所属的类。

如上述示例中的：

(new A)->dd(); 
(new B)->dd();

Copier après la connexion

static 和 $this 有点类似，但又有区别：

$this 指向的对象所属的类和 static 指向的类相同。
$this 不能用于静态方法中，也不能访问类的静态属性和常量。
$this 指向的是实际调用的对象。
static 可以用于静态或非静态方法中，也可以访问类的静态属性、静态方法、常量和非静态方法，但不能访问非静态属性。
static 指向的是实际调用时的对象所属的类。

Renvoi d'appel (renvoi d'appel)

Le soi-disant renvoi d'appel (renvoi d'appel) fait référence aux appels statiques passés des manières suivantes : soi : , parent : , statique :: et forward_static_call().

Vous pouvez utiliser la fonction get_call_class() pour obtenir le nom de classe de la méthode appelée.

Les quatre formes d'appels suivantes sont toutes des transferts d'appels :

lui-même ::
parent ::
static::
forward_static_call()

Les appels autres que celui-ci sont des appels sans transfert.

Appel sans renvoi (appel sans renvoi)

Liaison statique tardive fonctionne en stockant l'appel sans renvoi précédent (non renvoi appel) nom de la classe.

Les appels passés via des noms de classe spécifiques ou des objets spécifiques sont des appels non transférés.

Par exemple :

A::test2(); 
B::test2(); 

(new A)->dd(); 
(new B)->dd();

Copier après la connexion

注意事项

非静态环境下的私有方法的查找顺序

在非静态环境下，在类的非静态方法中，使用 $this 和 static 调用类的私有方法时，执行方式有所不同。

$this 会优先寻找所在定义范围（父类）中的私有方法，如果存在就调用。
static 是先到它指向的类（子类）中寻找私有方法，如果找到了就会报错，因为私有方法只能在它所定义的类内部调用；如果没找到，再去所在定义范围（父类）中寻找该私有方法，如果存在就调用。

具体来说，$this 会先到所在定义范围内寻找私有方法，再到它指向的对象所属的类中寻找私有方法，然后寻找公有方法，最后到所在定义范围内寻找公共方法。只要找到了匹配的方法，就调用，并停止查找。

而 static 则是先到它指向的类中寻找私有方法，再寻找共有方法；然后到所在定义范围内寻找私有方法，再寻找共有方法。只要找到了匹配的方法，就调用，并停止查找。

下面是一个例子：

<?php
 class  A  {    private function  foo () {
        var_dump($this); echo '--';
        var_dump(new static); echo '--';        echo __CLASS__; echo '--';        echo get_called_class();        echo '<br>';
    }    public function  test () {        $this -> foo ();        static:: foo ();        echo '<br>';
    }
}class  B  extends  A  { }class  C  extends  A  {    private function foo () {        echo 'this is C';
    }
}

(new  B())->test();
(new  C())->test();

Copier après la connexion

输出结果为：

object(B)#1 (0) { } --object(B)#2 (0) { } --A--B
object(B)#1 (0) { } --object(B)#2 (0) { } --A--B

object(C)#1 (0) { } --object(C)#2 (0) { } --A--C

Fatal error: Uncaught Error: Call to private method C::foo() from context 'A'

Copier après la connexion

关于后期静态绑定的解析

后期静态绑定的解析会一直到取得一个完全解析了的静态调用为止。如果静态调用使用了 parent:: 或者 self:: 等转发调用的形式，将会转发调用信息。

<?phpclass  A  {    public static function  foo () {        static:: who ();
    }    public static function  who () {        echo  __CLASS__ . "\n" ;
    }
}class  B  extends  A  {    public static function  test () {
        A :: foo ();        parent :: foo ();        self :: foo ();        static::foo();
        forward_static_call(['A', 'foo']);        echo '<br>';
    }    public static function  who () {        echo  __CLASS__ . "\n" ;
    }
}class  C  extends  B  {    public static function  who () {        echo  __CLASS__ . "\n" ;
    }    public static function test2() {        self::test();
    }
}class  D  extends  C  {    public static function  who () {        echo  __CLASS__ . "\n" ;
    }
}

B::foo();
B::test();

C::foo();
C::test();

D::foo();
D::test2();

Copier après la connexion

以上的输出结果为：

B A B B B B 
C A C C C C D A D D D D

Copier après la connexion

static 后期静态绑定的工作原理是存储了上一个非转发调用（non-forwarding call）的类名。请记住这句话。

下面的例子是非转发调用。

A::foo();  // 输出 AB::foo();   // 输出 BC::foo();   // 输出 C

Copier après la connexion

后期静态绑定 static ，是定义在了 foo() 方法中，哪个类通过非转发调用的形式调用 foo() 方法， foo() 方法中的 static 指向的就是哪个类。

但是，如果通过转发调用的形式，调用 foo() 方法，如：

parent :: foo ();self :: foo ();static::foo();forward_static_call(['A', 'foo']);

Copier après la connexion

那么，就以转发调用代码所在的方法 test() 为准，哪个类通过非转发调用的形式调用 test() 方法， foo() 方法中的 static 指向的就是哪个类。

假如调用 test() 方法时，也采用了转发调用的形式，如：

public static function test2() {    self::test();
}

Copier après la connexion

那么，就以 test2() 方法为准 ... 依次类推。

也就是说，在使用了后期静态绑定的基类中，后期静态绑定所在的方法如果被转发调用，则 static 的指向，会一直向上追溯，直到遇到非转发调用的形式。

Php8, je viens aussi

Apprenez la mise en page d'un site Web en 30 minutes

Tutoriel vidéo Shangguan Oracle débutant à compétent

Votre première ligne de code UNI-APP

Flutter de zéro au lancement de l'application

Brother Lian Nouveau didacticiel vidéo Linux

Tutoriel vidéo AXURE 9 (convient à l'interface utilisateur interactive de conception de produits du chef de produit)

Tutoriel vidéo PS Zero Basic Proficiency

Tutoriel vidéo de 16 jours sur l'interface utilisateur pour vous aider à démarrer

Tutoriel vidéo sur les techniques PS et les techniques de découpage

Tutoriel vidéo sur la construction et le lancement de projets d'Alibaba Cloud Environment

Présentation des réseaux informatiques - Connaissances de base que les programmeurs doivent maîtriser

Tutoriel essentiel pour les programmeurs - Explication du protocole HTTP

Tutoriel vidéo Websocket

Explication détaillée des différences entre les liaisons self, static, $this et late static en PHP

La différence entre self, static et $this

Liaison statique tardive

工作原理

Renvoi d'appel (renvoi d'appel)

注意事项

非静态环境下的私有方法的查找顺序

关于后期静态绑定的解析