Kennen Sie die Verwendung dieses Schlüsselworts in Thinkphp5?

PHP verfügt seit 5 über die meisten objektorientierten Sprachfunktionen. Es verfügt über viel mehr objektorientierte Funktionen als PHP4. Hier erklären wir hauptsächlich drei Schlüsselwörter: this, self, parent, from The literal Die Bedeutung ist leichter zu verstehen. Lassen Sie uns zunächst einige Konzepte festlegen. Erklären wir kurz, dass dies ein Zeiger auf das aktuelle Objekt ist in C) ist self ein Zeiger auf die aktuelle Klasse und parent ein Zeiger auf die übergeordnete Klasse.

Im Folgenden wird anhand von Beispielen erläutert.

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

Wir sehen, dass die obige Klasse diesen Zeiger jeweils in den Zeilen 11 und 20 verwendet. Auf wen zeigt dieser Zeiger zu diesem Zeitpunkt? Tatsächlich bestimmt dies, auf wen es zeigt, wenn es instanziiert wird. Wenn das Objekt beispielsweise zum ersten Mal instanziiert wird (Zeile 25), dann zeigt dies auf das $nameObject-Objekt, also auf das Drucken von Zeile 18 wird ausgeführt. Dann wird print( $this->name ) geändert, dann wird natürlich „heiyeluren“ ausgegeben. Im zweiten Fall wird print( $this->name ) zu print( $nameObject2->name ), sodass „PHP5“ ausgegeben wird. Daher ist dies ein Zeiger auf die aktuelle Objektinstanz und zeigt nicht auf ein anderes Objekt oder eine andere Klasse.

(2)self

Zunächst müssen wir klarstellen, dass self auf die Klasse selbst verweist, das heißt, self zeigt nicht auf ein instanziiertes Objekt Wird verwendet, um auf statische Objekte in der Klassenvariablen zu verweisen.

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

Wir müssen hier nur auf zwei Stellen achten, die Zeilen 6 und 12. Wir haben in der zweiten Zeile eine statische Variable $firstCount definiert, deren Anfangswert 0 ist. Dann haben wir diesen Wert in Zeile 12 aufgerufen, ihn mit self aufgerufen und mit „::“ eine Verbindung in der Mitte hergestellt, was wir auch getan haben Rufen Sie den Domänenoperator auf. Zu diesem Zeitpunkt rufen wir die von der Klasse selbst definierte statische Variable $ frestCount auf. Unsere statische Variable hat nichts mit der Instanz des folgenden Objekts zu tun, sondern bezieht sich nur auf die Klasse die Klasse selbst, dann können wir dies nicht zum Referenzieren verwenden. Sie können self zum Referenzieren verwenden, da self auf die Klasse selbst verweist und nichts mit einer Objektinstanz zu tun hat. Mit anderen Worten: Wenn unsere Klasse statische Mitglieder hat, müssen wir sie auch mit self aufrufen.

(3)parent

Wir wissen, dass parent ein Zeiger auf die übergeordnete Klasse ist. Im Allgemeinen verwenden wir parent, um den Konstruktor der übergeordneten Klasse aufzurufen.

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

Wir achten auf diese Details: Mitgliedsattribute sind alle öffentlich, insbesondere die der übergeordneten Klasse, damit geerbte Klassen darüber darauf zugreifen können. Wir achten auf den entscheidenden Punkt, Zeile 25: parent:: construction( "heiyeluren" ). Zu diesem Zeitpunkt verwenden wir parent, um den Konstruktor der übergeordneten Klasse aufzurufen, um die übergeordnete Klasse zu initialisieren, da die Mitglieder der übergeordneten Klasse vorhanden sind alle öffentlich. Wir können dies also direkt verwenden, um die geerbte Klasse aufzurufen.