Do you know the usage of this keyword in Thinkphp5?

PHP has had most of the object-oriented language features since 5. It has many more object-oriented features than PHP4. Here we mainly explain three keywords: this, self, parent, from Literally easier to understand, it refers to this, myself, and father. Let’s establish a few concepts first. Where are these three keywords used? Let’s briefly explain that this is a pointer to the current object (let’s use Let’s look at the pointers in C), self is a pointer to the current class, and parent is a pointer to the parent class.

The following explains through examples.

(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
?>

We see that the above class uses this pointer on lines 11 and 20 respectively, so who does this point to at that time? In fact, this determines who it points to when instantiating it. For example, when the object is instantiated for the first time (line 25), then this is pointing to the $nameObject object, so the printing of line 18 is executed. Then print( $this->name ), then of course "heiyeluren" is output. In the second instance, print( $this->name ) becomes print( $nameObject2->name ), so "PHP5" is output. Therefore, this is a pointer to the current object instance and does not point to any other object or class.

(2)self

First of all, we have to make it clear that self points to the class itself, that is, self does not point to any instantiated object. Generally, self is used to point to static objects in the class. variable.

<?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
?>

We only need to pay attention to two places here, lines 6 and 12. We defined a static variable $firstCount on the second line, and the initial value is 0. Then we called this value on line 12, using self to call it, and using "::" to connect in the middle, which is what we call domain operator, then what we call at this time is the static variable $frestCount defined by the class itself. Our static variable has nothing to do with the instance of the following object, it is only related to the class, then if I call the class itself, then we cannot Use this to reference, you can use self to reference, because self points to the class itself and has nothing to do with any object instance. In other words, if there are static members in our class, we must also use self to call them.

(3)parent

We know that parent is a pointer to the parent class. Generally, we use parent to call the constructor of the parent class.

<?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
?>

We pay attention to the following details: member attributes are all public, especially those of the parent class, for inherited classes to access through this. We pay attention to the key point, line 25: parent:: construct( "heiyeluren" ). At this time, we use parent to call the constructor of the parent class to initialize the parent class, because the members of the parent class are all public. So we can directly use this to call in the inherited class.