Explication détaillée des différences et de l'utilisation des mots-clés this, self et parent en php

{一}Une des différences entre ceci, soi, parent en PHP, cet article

La programmation orientée objet (POO, Programmation Orientée Objet) est désormais devenue une compétence de base pour programmeurs. L'utilisation d'idées POO pour la programmation avancée de PHP est très utile pour améliorer les capacités de programmation PHP et planifier l'architecture de développement Web.
Après avoir été réécrit, PHP5 a fait un grand pas en avant dans sa prise en charge de la POO et est devenu un langage doté de la plupart des fonctionnalités d'un langage orienté objet. Il possède beaucoup plus de fonctionnalités orientées objet que PHP4. Ce dont je parle principalement ici, c'est la différence entre les trois mots-clés this, self et parent. Littéralement compris, ils font référence à cela, respectivement à moi et à mon père. Permettez-moi d'abord de donner une explication préliminaire. Il s'agit d'un pointeur vers l'objet actuel (peut être considéré comme un pointeur en C), self est un pointeur vers la classe actuelle et parent est un pointeur vers la classe parent. Nous utilisons fréquemment des pointeurs pour décrire ici car il n'y a pas de meilleur langage pour l'exprimer. Concernant la notion de pointeurs, vous pouvez vous référer à l'encyclopédie.
Parlons-en à partir d’exemples concrets.

Le code est le suivant :

<?php
  classname          //建立了一个名为name的类
 {
    private$name;         //定义属性，私有
    //定义
构造函数
，用于初始化赋值
    function construct( $name )
    {
         $this->name =$name;         //这里已经使用了this指针语句①
    }
    //
析构函数
    function destruct(){}
    //打印用户名成员函数
    function printname()
    {
         print( $this->name);             //再次使用了this指针语句②，也可以使用echo输出
    }
 }
 $obj1 = new name("PBPHome");   //实例化对象 语句③
 //执行打印
 $obj1->printname(); //输出:PBPHome
 echo"<br>";                                    //输出：回车
 //第二次实例化对象
 $obj2 = new name( "PHP" );
 //执行打印
 $obj2->printname();                         //输出：PHP
 ?>

Explication : La classe ci-dessus utilise ce pointeur dans l'instruction ① et l'instruction ② respectivement. Alors, à qui cela indiquait-il à ce moment-là ? En fait, cela détermine vers qui il pointe lors de son instanciation. Par exemple, lorsque l'objet est instancié pour la première fois (instruction ③), alors cela pointe vers l'objet $obj1 à ce moment-là. , print( $this- >3a6d53f8df6eb817e21da459ac97aa86name ), puis bien sûr "PBPHome" est affiché. Dans le deuxième cas, print($this->name) devient print($obj2->name), donc "PHP" est affiché. Par conséquent, il s’agit d’un pointeur vers l’instance d’objet actuelle et ne pointe vers aucun autre objet ou classe.

{2} La différence entre ceci, self et parent en PHP Partie 2 self

Dans cet article, nous expliquerons l'utilisation de self
Tout d'abord, nous devons être clairs ce self fait référence à la classe elle-même, c'est-à-dire que self ne pointe vers aucun objet instancié. Généralement, self est utilisé pour pointer vers des variables statiques de la classe. Si nous utilisons des membres statiques dans la classe (généralement en utilisant le mot-clé static), nous devons également utiliser self pour appeler. Notez également que l'utilisation de self pour appeler des variables statiques doit utiliser :: (champ opérateur numéro), voir exemple.

Le code est le suivant :

<?php
    classcounter     //定义一个counter的类
    {
        //定义属性，包括一个静态变量$firstCount，并赋初值0 语句①  
        private static $firstCount = 0;
        private $lastCount;
        //构造函数
        function construct()
        {
             $this->lastCount =++self::$firstCount;      //使用self来调用静态变量 语句②
        }
        //打印lastCount数值
        function printLastCount()
        {
             print( $this->lastCount );
        }
    }
  //实例化对象
  $obj = new Counter();
 $obj->printLastCount();                             //执行到这里的时候，程序输出1
 ?>

Il y a deux endroits auxquels il faut prêter attention, la déclaration ① et la déclaration ②. Nous avons défini une variable statique $firstCount dans l'instruction ①, puis avons utilisé self pour appeler cette valeur dans l'instruction ②. Ensuite, ce que nous appelons à ce stade est la variable statique $frestCount définie par la classe elle-même. Notre variable statique n'a rien à voir avec l'instance de l'objet suivant, elle est uniquement liée à la classe elle-même, alors nous ne pouvons pas l'utiliser pour y faire référence, car self pointe vers la classe elle-même et a. rien à voir avec une instance d'objet. Ensuite, le this utilisé précédemment appelle l'objet instancié $obj, alors ne vous y trompez pas.
C'est tout pour soi. C'est plus facile à comprendre avec des exemples. La fin du deuxième chapitre.

{3} La différence entre ceci, self et parent dans PHP Partie 3 parent

Dans cet article, nous expliquerons l'utilisation de parent.
Tout d'abord, nous précisons que parent est un pointeur vers la classe parent. Généralement, nous utilisons parent pour appeler le constructeur de la classe parent. L'exemple est le suivant :

Le code est le suivant :

<?php
 //建立基类Animal
 class Animal
 {
    public $name; //基类的属性，名字$name
    //基类的构造函数，初始化赋值
    public function construct( $name )
    {
         $this->name = $name;
    }
 }
 //定义派生类Person 继承自Animal类
 class Person extends Animal
 {
    public$personSex;       //对于派生类，新定义了属性$personSex性别、$personAge年龄
    public $personAge;
    //派生类的构造函数
    function construct( $personSex, $personAge )
    {
         parent::construct( "PBPHome");    //使用parent调用了父类的构造函数 语句①
         $this->personSex = $personSex;
         $this->personAge = $personAge;
    }
    //派生类的成员函数，用于打印，格式：名字 is name,age is 年龄
    function printPerson()
    {
         print( $this->name. " is ".$this->personSex. ",age is ".$this->personAge );
     }
 }
 //实例化Person对象
 $personObject = new Person( "male", "21");
 //执行打印
 $personObject->printPerson();//输出结果：PBPHome is male,age is 21
 ?>

qui contient également l'usage de ceci, vous pouvez l'analyser vous-même. Nous faisons attention à ce détail : les attributs des membres sont tous publics ( attributs et méthodes publics , accessibles au code à l'intérieur et à l'extérieur de la classe), notamment ceux de la classe parent. Il s'agit des classes héritées auxquelles on peut accéder via. cet accès. Le point clé est l'instruction ① : parent::construct("heiyeluren") À ce stade, nous utilisons parent pour appeler le constructeur de la classe parent afin d'initialiser la classe parent. De cette manière, les objets de la classe héritée sont attribués. le nom PBPHome. Nous pouvons le tester en instanciant un autre objet $personObject1 Après impression, le nom est toujours PBPHome.
Résumé : il s'agit d'un pointeur vers une instance d'objet, qui est déterminé lors de l'instanciation ; self est une référence à la classe elle-même, généralement utilisée pour pointer vers des variables statiques dans la classe parent ; , parent est utilisé pour appeler le constructeur de la classe parent.

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!