Obtenez le mot-clé personnel de PHP en quelques minutes

Vous ne pouvez pas utiliser ceci pour appeler des fonctions non membres dans une fonction membre statique, mais vous pouvez utiliser self pour appeler des fonctions/variables/constantes membres statiques

Autre ; Les fonctions membres peuvent être appelées avec des fonctions membres auto-statiques et des fonctions membres non statiques.

Au fur et à mesure que la discussion s'approfondissait, j'ai découvert que le soi n'est pas si simple. Compte tenu de cela, cet article compare et différencie d'abord plusieurs mots-clés, puis résume l'utilisation de soi.

Différences avec le parent, statique et ceci

Si vous voulez bien comprendre le soi, vous devez le distinguer du parent, statique et ceci.

Vous ne pouvez pas l'utiliser pour appeler des fonctions non membres dans une fonction membre statique, mais vous pouvez utiliser self pour appeler des fonctions/variables/constantes membres statiques

D'autres fonctions membres peuvent utiliser self pour ; appeler des fonctions membres statiques et des fonctions membres de fonctions non statiques.

Au fur et à mesure que la discussion s'approfondissait, j'ai découvert que le soi n'est pas si simple. Compte tenu de cela, cet article compare et différencie d'abord plusieurs mots-clés, puis résume l'utilisation de soi.

Différences avec le parent, statique et ceci

Si vous voulez bien comprendre le soi, vous devez le distinguer du parent, statique et ceci.

class Base {
    public function __construct() {
        echo "Base contructor!", PHP_EOL;
    }
}
  
class Child {
    public function __construct() {
        parent::__construct();
        echo "Child contructor!", PHP_EOL;
    }
}
  
new Child;
// 输出：
// Base contructor!
// Child contructor!

static

Le but général de static est de modifier des fonctions ou des variables pour en faire des fonctions de classe et des variables de classe. Il peut également modifier des variables au sein des fonctions pour étendre leur cycle de vie au cycle de vie. de l'ensemble de la demande.

Mais son association avec self est une nouvelle utilisation introduite depuis PHP 5.3 : la liaison statique retardée.

Avec la fonction de liaison de délai statique de static, la classe appartenant peut être déterminée dynamiquement au moment de l'exécution.

Par exemple :

class Base {
    public function __construct() {
        echo "Base constructor!", PHP_EOL;
    }
  
    public static function getSelf() {
        return new self();
    }
  
    public static function getInstance() {
        return new static();
    }
  
    public function selfFoo() {
        return self::foo();
    }
  
    public function staticFoo() {
        return static::foo();
    }
  
    public function thisFoo() {
        return $this->foo();
    }
  
    public function foo() {
        echo  "Base Foo!", PHP_EOL;
    }
}
  
class Child extends Base {
    public function __construct() {
        echo "Child constructor!", PHP_EOL;
    }
  
    public function foo() {
        echo "Child Foo!", PHP_EOL;
    }
}
  
$base = Child::getSelf();
$child = Child::getInstance();
  
$child->selfFoo();
$child->staticFoo();
$child->thisFoo();

Le résultat du programme est le suivant :

Base constructor!
Child constructor!
Base Foo!
Child Foo!
Child Foo!

En termes de références de fonction, la différence entre self et static est : pour les fonctions membres statiques, self pointe vers la classe actuelle du code, static pointe vers la classe appelante ; pour les fonctions membres non statiques, self supprime le polymorphisme et pointe vers la fonction membre de la classe actuelle, static est équivalent à cela et Dynamic pointe vers la fonction de la classe appelante.

Il est intéressant de voir les trois mots-clés parent, self et static combinés ensemble. Ils pointent respectivement vers la classe parent, la classe actuelle et la sous-classe, qui ont un peu un « passé, présent et futur ». " saveur.

ce

soi et ceci sont les combinaisons les plus discutées et sont également les plus susceptibles d'être utilisées à mauvais escient.

Les principales différences entre les deux sont les suivantes :

this ne peut pas être utilisé dans les fonctions membres statiques, self peut

pour les fonctions membres statiques ; /variables Pour l'accès, il est recommandé d'utiliser self au lieu de $this:: ou $this->

Pour accéder aux variables membres non statiques, self ne peut pas être utilisé, seulement ceci

ceci doit être utilisé lorsque l'objet a été instancié, self n'a pas cette restriction ;

est utilisé dans les fonctions membres non statiques, self supprime le comportement polymorphe et fait référence à la fonction de la classe actuelle ; ceci fait référence à la fonction lourde de la classe appelante. Remplacer la fonction (le cas échéant).

Le but de soi

Après avoir lu les différences entre les trois mots-clés ci-dessus, le but de soi est-il immédiatement évident ? Pour résumer en une phrase, c'est-à-dire : self pointe toujours vers "la classe actuelle (et l'instance de classe)".

En détail :

remplace le nom de la classe et fait référence aux variables membres statiques et aux fonctions statiques de la classe actuelle

supprime le comportement polymorphe et fait référence aux fonctions de la classe actuelle ; classe actuelle au lieu de l'implémentation remplacée dans les sous-classes

Slots

这几个关键字中，只有this要加$符号且必须加，强迫症表示很难受；

静态成员函数中不能通过$this->调用非静态成员函数，但是可以通过self::调用，且在调用函数中未使用$this->的情况下还能顺畅运行。此行为貌似在不同PHP版本中表现不同，在当前的7.3中ok；

在静态函数和非静态函数中输出self，猜猜结果是什么？都是string(4) "self"，迷之输出；

return $this instanceof static::class;会有语法错误，但是以下两种写法就正常：

$class = static::class;
return $this instanceof $class;
// 或者这样：
return $this instanceof static;

所以这是为什么啊？！

$class = static::class;

return $this instanceof $class;

// 或者这样：

return $this instanceof static;

以上就是解析PHP的self关键字的详细内容。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!