Explication détaillée du mot-clé self en PHP

Analyse du mot-clé self de PHP

Quelqu'un dans le groupe PHP a posé des questions sur l'utilisation du mot-clé self, et la réponse est une comparaison évidente :

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 utiliser self pour appeler des fonctions membres 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.

Pour bien comprendre le soi, il faut le distinguer du parent, du statique, et ce.

Ce qui suit sont des comparaisons

parent

La distinction entre soi et le parent est relativement simple : la référence du parent à la classe/base parent la classe est une méthode (ou une variable) masquée, self fait référence à sa propre méthode (ou variable).

Par exemple, appeler le constructeur de la classe parent dans le constructeur :

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 les variables de classe, vous pouvez également modifier les variables au sein d'une fonction pour étendre leur cycle de vie au cycle de vie de l'ensemble de l'application.

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 :

Constructeur de base !
Constructeur enfant !
Base Foo !
Child Foo !
Child Foo !

En termes de références de fonctions, la différence entre self et static est la suivante : pour les fonctions membres statiques, self pointe vers la classe actuelle du code, et static pointe vers la classe appelante ; pour les membres non statiques Function, self supprime le polymorphisme, 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.

La principale différence entre les deux est la suivante :

cela ne peut pas être utilisé dans un membre statique function, self Oui;

Pour accéder aux fonctions/variables membres statiques, il est recommandé d'utiliser self au lieu de $this:: ou $this->

Pour accéder à des fonctions non- variables membres statiques, vous ne pouvez pas utiliser self, seulement ceci ;

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

est utilisé dans les fonctions membres non statiques, self supprime le polymorphisme Behavior fait référence à la fonction de la classe actuelle et ceci fait référence à la fonction primordiale de la classe appelante (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 les références ; Fonctions de la classe actuelle plutôt que les implémentations couvertes dans les sous-classes

Slots

Parmi ces mots-clés, seul This doit être ajouté avec un signe $ et doit être ajouté Le trouble obsessionnel-compulsif signifie que c'est très inconfortable

Les fonctions membres statiques ne peuvent pas appeler les fonctions membres non statiques via $this->, mais elles peuvent être appelées via self : :, et lors de l'appel de la fonction, elle peut toujours fonctionner correctement sans utiliser $this->. Ce comportement semble se comporter différemment selon les différentes versions de PHP, mais il est correct dans la version 7.3 actuelle

 ;

在静态函数和非静态函数中输出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视频教程》

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!