Explication détaillée sur l'utilisation du mot-clé self en PHP

Différences avec le parent, statique et ceci

Si vous voulez bien comprendre le soi, vous devez le distinguer du parent, statique et ceci. Des comparaisons sont faites ci-dessous.

parent

La distinction entre self et parent est relativement simple : parent fait référence à la méthode (ou variable) cachée de la classe parent/classe de base, et self fait référence à sa propre méthode (ou variables). Par exemple, appeler le constructeur de la classe parent dans le constructeur : (Partage gratuit du didacticiel vidéo d'apprentissage : tutoriel vidéo php)

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 objectif général Il s'agit de modifier des fonctions ou des variables pour les transformer en fonctions de classe et en variables de classe. Vous pouvez également modifier des variables au sein des fonctions 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 statique retardée 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 de sortie est le suivant :

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 du classe actuelle, static est équivalent à cela et Dynamic pointe vers la fonction de la classe appelante.

Les trois mots-clés parent, self et static sont très intéressants à regarder 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 les plus susceptibles d'être mal utilisées.

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

1 ceci ne peut pas être utilisé dans les fonctions membres statiques, self peut ; variables, Il est recommandé d'utiliser self au lieu de $this:: ou $this->;

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

Le but de soi

Après avoir lu les différences avec 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)". Les détails sont :

tutoriel 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!