Connaissez-vous l'utilisation de ce mot-clé dans Thinkphp5 ?

PHP possède la plupart des fonctionnalités du langage orienté objet depuis la version 5. Il possède beaucoup plus de fonctionnalités orientées objet que PHP4. Nous expliquons ici principalement trois mots-clés : this, self, parent, de The littéral. le sens est plus facile à comprendre. Il fait référence à cela, à moi-même et à mon père. Établissons d'abord quelques concepts. Où sont utilisés ces trois mots-clés ? Expliquons brièvement qu'il s'agit d'un pointeur vers l'objet actuel (utilisons Regardons les pointeurs). en C), self est un pointeur vers la classe actuelle et parent est un pointeur vers la classe parent.

Ce qui suit explique à travers exemples.

(1) this

<?php
class UserName
{
//定义属性
private $name;
//定义构造函数
function construct( $name ){
$this->name = $name; //这里已经使用了this指针
}
//析构函数
function destruct(){}
//打印用户名成员函数
function printName(){
print( $this->name ); //又使用了this指针
}
}
//实例化对象
$nameObject = new UserName( "heiyeluren" );
//执行打印
$nameObject->printName(); //输出: heiyeluren
//第二次实例化对象
$nameObject2 = new UserName( "PHP5" );
//执行打印
$nameObject2->printName(); //输出：PHP5
?>

Nous voyons que la classe ci-dessus utilise ce pointeur sur les lignes 11 et 20 respectivement, alors à qui ce point pointe-t-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 (ligne 25), alors cela pointe vers l'objet $nameObject, puis l'impression. de la ligne 18 est exécuté. Ensuite, print( $this->name ), puis bien sûr "heiyeluren" est affiché. Dans le deuxième cas, print( $this->name ) devient print( $nameObject2->name ), donc "PHP5" 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)self

Tout d'abord, nous devons préciser que self pointe vers 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 objets statiques dans la variable de classe.

<?php
class Counter
{
//定义属性，包括一个静态变量
private static $firstCount = 0;
private $lastCount;
//构造函数
function construct(){
$this->lastCount = ++selft::$firstCount; //使用self来调用静态变量,使用self调用必须使用::(域运算符号)
}
//打印最次数值
function printLastCount(){
print( $this->lastCount );
}
}
//实例化对象
$countObject = new Counter();
$countObject->printLastCount(); //输出 1
?>

Il suffit de faire attention à deux endroits ici, les lignes 6 et 12. Nous avons défini une variable statique $firstCount sur la deuxième ligne et la valeur initiale est 0. Ensuite, nous avons appelé cette valeur sur la ligne 12, en utilisant self pour l'appeler et en utilisant "::" pour nous connecter au milieu, ce que nous avons appelez l'opérateur de domaine, alors ce que nous appelons à ce moment 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, alors si j'appelle. la classe elle-même, alors nous ne pouvons pas utiliser ceci pour faire référence, vous pouvez utiliser self pour faire référence, car self pointe vers la classe elle-même et n'a rien à voir avec une instance d'objet. En d’autres termes, s’il y a des membres statiques dans notre classe, nous devons également utiliser self pour les appeler.

(3)parent

Nous savons que parent est un pointeur vers la classe parent. Généralement, nous utilisons parent pour appeler le constructeur de la classe parent.

<?php
//基类
class Animal
{
//基类的属性
public $name; //名字
//基类的构造函数
public function construct( $name ){
$this->name = $name;
}
}
//派生类
class Person extends Animal //Person类继承了Animal类
{
public $personSex; //性别
public $personAge; //年龄
//继承类的构造函数
function construct( $personSex, $personAge ){
parent::construct( "heiyeluren" ); //使用parent调用了父类的构造函数
$this->personSex = $personSex;
$this->personAge = $personAge;
}
function printPerson(){
print( $this->name. " is " .$this->personSex. ",this year " .$this->personAge );
}
}
//实例化Person对象
$personObject = new Person( "male", "21");
//执行打印
$personObject->printPerson(); //输出：heiyeluren is male,this year 21
?>

Nous prêtons attention à ces détails : les attributs des membres sont tous publics, en particulier ceux de la classe parent, pour que les classes héritées puissent y accéder. Nous prêtons attention au point clé, ligne 25 : parent:: construct( "heiyeluren" ). À ce stade, nous utilisons parent pour appeler le constructeur de la classe parent pour initialiser la classe parent, car les membres de la classe parent sont all public. Nous pouvons donc l'utiliser directement pour appeler la classe héritée.