Quelle est l'utilisation de soi dans Laravel

Dans Laravel, le mot-clé self est utilisé pour remplacer le nom de la classe. Il peut faire référence aux variables membres statiques et aux fonctions statiques de la classe actuelle. Il est également utilisé pour supprimer le comportement polymorphe. au lieu de l'implémentation couverte dans la sous-classe, self pointe toujours vers la classe et l'instance de classe actuelles.

L'environnement d'exploitation de cet article : système Windows 10, Laravel version 6, ordinateur Dell G3.

Quelle est l'utilisation de self dans Laravel

Vous ne pouvez pas utiliser this pour appeler des fonctions non membres dans une fonction membre statique, mais vous pouvez utiliser self pour appeler static fonctions membres/variables/constantes ; 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 self n'était 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 self. this 调用非成员函数，但可以用 self 调用静态成员函数/变量/常量；其他成员函数可以用 self 调用静态成员函数以及非静态成员函数。随着讨论的深入，发现 self 并没有那么简单。鉴于此，本文先对几个关键字做对比和区分，再总结 self 的用法。

与 parent 、 static 以及 this 的区别

要想将彻底搞懂 self ，要与 parent 、 static 以及 this 区分开。以下分别做对比。

parent

self 与 parent 的区分比较容易： parent 引用父类/基类被隐盖的方法（或变量）， self则引用自身方法（或变量）。例如构造函数中调用父类构造函数：

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 常规用途是修饰函数或变量使其成为类函数和类变量，也可以修饰函数内变量延长其生命周期至整个应用程序的生命周期。但是其与 self 关联上是PHP 5.3以来引入的新用途：静态延迟绑定。

有了 static 的静态延迟绑定功能，可以在运行时动态确定归属的类。例如：

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();

程序输出结果如下：

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

在函数引用上， self 与 static 的区别是：对于静态成员函数， self 指向代码当前类， static 指向调用类；对于非静态成员函数， self 抑制多态，指向当前类的成员函数， static 等同于 this ，动态指向调用类的函数。

parent 、 self 、 static 三个关键字联合在一起看挺有意思，分别指向父类、当前类、子类，有点“过去、现在、未来”的味道。

this

self 与 this 是被讨论最多，也是最容易引起误用的组合。两者的主要区别如下：

1. this 不能用在静态成员函数中， self 可以；
2. 对静态成员函数/变量的访问， 建议 用 self ，不要用 $this:: 或 $this-> 的形式；
3. 对非静态成员变量的访问，不能用 self ，只能用 this ;
4. this 要在对象已经实例化的情况下使用， self 没有此限制；
5. 在非静态成员函数内使用， self 抑制多态行为，引用当前类的函数；而 this 引用调用类的重写(override)函数（如果有的话）。

self 的用途

看完与上述三个关键字的区别， self 的用途是不是呼之即出？一句话总结，那就是： self

La différence entre parent, static et this🎜🎜Pour bien comprendre self, vous devez interagir avec parent , static et this se distinguent. Des comparaisons sont faites ci-dessous. 🎜

parent

🎜self et parent sont plus faciles à distinguer : parent fait référence au classe parent /La méthode (ou variable) de la classe de base est masquée et self fait référence à sa propre méthode (ou variable). Par exemple, appeler le constructeur de la classe parent dans le constructeur : 🎜rrreee

static

🎜static L'objectif général est de modifier la fonction ou la variable pour créer c'est une fonction de classe et les variables de classe peuvent également être modifiées pour étendre le cycle de vie des variables au sein d'une fonction 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 : 🎜rrreee🎜Le résultat du programme est le suivant : 🎜rrreee🎜En termes de références de fonctions, la différence entre self et static est : pour les fonctions membres statiques, self code> 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 code> est équivalente à <code>this, pointant dynamiquement vers la fonction de la classe appelante. 🎜🎜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. Il y a un côté un peu "passé, présent, futur". 🎜

this

🎜self et this 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. this ne peut pas être utilisé dans les fonctions membres statiques, self le peut ; pour les membres statiques Pour l'accès aux fonctions/variables, il est recommandé d'utiliser self au lieu de $this:: ou $this->;
2. Pour accéder aux variables membres non statiques, self ne peut pas être utilisé, seulement this;
3. this est obligatoire Lorsqu'il est utilisé lorsque l'objet a été instancié, self n'a pas cette restriction ;
4. Lorsqu'il est utilisé dans une fonction membre non statique, self supprime le comportement polymorphe fait référence à la fonction de la classe actuelle ; et this fait référence à la fonction prioritaire de la classe appelante (s'il y en a une).

🎜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 : 🎜

1. Remplacez le nom de la classe, faites référence aux variables membres statiques et aux fonctions statiques de la classe actuelle ;
2. Supprimez le comportement polymorphe, faites référence aux fonctions de la classe actuelle au lieu de l'implémentation couverte dans la sous-classe ;
Ce sont les points clés Parmi les personnages, seul ce doit être ajouté avec le symbole $ et doit être ajouté. Le trouble obsessionnel-compulsif signifie qu'il est très inconfortable ;

$this-> appelle une fonction membre non statique, mais elle peut être appelée via self:: et peut même fonctionner correctement. si $this-> n'est pas utilisé dans la fonction appelante. Ce comportement semble se comporter différemment dans différentes versions de PHP. C'est ok dans la version 7.3 actuelle

self est affiché dans les fonctions statiques et les fonctions non statiques. Les deux sont string(4) "self", ce qui prête à confusion ;

1. return $this instanceof static::class; Il y aura des erreurs de syntaxe, mais les deux manières suivantes de l'écriture est normale : this 要加 $ 符号且必须加，强迫症表示很难受；
2. 静态成员函数中不能通过 $this-> 调用非静态成员函数，但是可以通过 self:: 调用，且在调用函数中未使用 $this-> 的情况下还能顺畅运行。此行为貌似在不同PHP版本中表现不同，在当前的7.3中ok；
3. 在静态函数和非静态函数中输出 self ，猜猜结果是什么？都是 string(4) "self" ，迷之输出；
4. return $this instanceof static::class; $class = static::class;
   return $this instanceof $class;
   // Ou comme ceci :
   return $this instanceof static;
   

【Recommandation associée :

tutoriel vidéo laravel】

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!