Explication détaillée 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 relativement évidente :

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

D'autres 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.

Différences avec le parent, statique et ceci

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

Ce qui suit sont des comparaisons

parent

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

Par exemple, appeler le constructeur de 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

static est généralement utilisé pour modifier des fonctions ou des variables pour en faire des fonctions de classe et des variables de classe. Il peut également être modifié. Les variables au sein d'une fonction prolongent leur cycle de vie jusqu'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. Recommandé : "Tutoriel PHP"

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!

Dans les références de fonction, self Et static La différence 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 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 ; et cela 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 Mise en œuvre couverte dans les sous-classes ;

Slots

Parmi ces mots-clés, seul celui-ci doit être ajouté avec le signe $ et doit être ajouté. Le trouble obsessionnel-compulsif signifie qu'il est très inconfortable. ;

Les fonctions membres non statiques ne peuvent pas être appelées via $this-> dans les fonctions membres statiques, mais elles peuvent être appelées via self::, et elles peuvent toujours s'exécuter correctement sans utiliser $this-> la fonction appelante. Ce comportement semble se comporter différemment dans les différentes versions de PHP. C'est ok dans la version 7.3 actuelle ;

affiche self dans les fonctions statiques et les fonctions non statiques. Ce sont tous des string(4) "self", ce qui est une sortie déroutante ;

return $this instanceof static::class; il y aura des erreurs de syntaxe, mais les deux façons d'écrire suivantes sont normales :

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

Alors pourquoi ça ? !

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

Pour plus de connaissances sur PHP, veuillez visiter le Site Web PHP chinois !

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!