Quelle est l'utilisation du mot-clé self en php

L'utilisation du mot-clé self en PHP est la suivante : 1. Remplacer le nom de la classe et faire référence aux variables membres statiques et aux fonctions statiques de la classe actuelle ; 2. Supprimer le comportement polymorphe et faire référence aux fonctions de la classe actuelle ; classe au lieu de les remplacer dans la réalisation des sous-classes. self pointe toujours vers la classe actuelle (et l’instance de classe).

Utilisation :

self pointe toujours vers "la classe actuelle (et l'instance de classe)".

Introduction détaillée :

1. Remplacez le nom de la classe et référencez les variables membres statiques et les fonctions statiques de la classe actuelle

2. de la classe actuelle. Plutôt que l'implémentation couverte dans la sous-classe

Ci-dessous, nous utilisons des exemples pour comparer avec parent , static et this;

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, le constructeur de la classe parent est appelé 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 L'objectif général est de modifier la fonction ou la variable pour en faire une fonction de classe et variable de classe, et elle peut également être modifiée. Les variables au sein d'une fonction étendent 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 du programme 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 de code actuelle, 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.

Pour plus de connaissances connexes, vous pouvez visiter le site Web chinois 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!