Detailed introduction to the difference between the constructor _construct() and _initialize() of classes in ThinkPHP

This article mainly introduces the constructor function of the class in ThinkPHP The difference between _construct() and _initialize(). The introduction in the article is very detailed. I believe it has certain reference value for everyone. Friends who need it Let’s take a look together below.

Preface

I believe that phpers who are familiar with THINKPHP are basically familiar with _initialize()This method, we seem to also _construct() is rarely used, unless you write a plug-in yourself, otherwise it is really rarely used.

Looking at the code today, I suddenly saw _construct()This construction method that comes with PHP. My first impression was that it was relatively unfamiliar, although I often used it when learning Java before. Encountered it, but haven’t used it for a long time and basically forgotten it. My usual habit is to write the key points of knowledge in my small notebook, but I haven't written for a long time, and the elegant and smart writing style I used in high school has completely disappeared into another dimension. In addition to the previous thoughts, I came to learn how to write blogs from technology experts. This is not to show off, but just to prevent every bit of the results of my work from dissipating with the passage of time. Let’s take a look at the detailed introduction below.

First paste the code (my environment is wamp, using the TP framework):

FatherAction.class created. php file

<?php


class FatherAction extends Action{
　　public function construct(){
　　　　echo &#39;father&#39;;
　　}
}

?>

The created SonAction.class.php file

<?php


class SonAction extends FatherAction{
　　public function construct(){
　　　　echo &#39;son&#39;;
　　}
function index(){

}
}

?>

can be viewed by running

index()

in the subclass SonAction The output result is: <pre class='brush:php;toolbar:false;'>son</pre>

If the subclass is changed to:

<?php


class SonAction extends FatherAction{
　　　public function construct(){
　　　　parent::construct();
　　　　echo &#39;son&#39;;
　　　}
　　function index(){

　　}
}

?>

, the running result is;

fatherson

The above results can be concluded: The constructor of the parent class will not be automatically called when executing the constructor of the subclass. If you want to call it, Then add

parent::construct()

When we change the above construction method to the

THINKPHP_initialize()

method, we will find that the result is the same as the previous one Consistently, if you want to execute the _initialize() method of the parent class, you also need to use this sentence: parent::_initialize() Does that mean that PHP comes with it? Is the constructor

construct()

the same as the _initialize() method of THINKPHP?

First paste two pieces of code:

<?php


class FatherAction extends Action{
　　public function construct(){
　　　　echo &#39;father&#39;;
　　}
}

?>

<?php


class SonAction extends FatherAction{
　　public function _initialize(){
　　　　echo &#39;son&#39;;
　　}


　　function index(){

　　}

}

?>

When the index method of the subclass SonAction is executed, it is found that the output result is: father

That is The subclass called the constructor of the parent class, but did not call the

_initialize()

method of the subclass

And then paste two pieces of code:

<?php


class FatherAction extends Action{
　　public function construct(){
　　　　if(method_exists($this,"hello")){
　　　　　　$this->hello();
　　　　}
　　　　echo &#39;father&#39;;
　　}
}

?>

<?php


class SonAction extends FatherAction{
　　public function _initialize(){
　　　　echo &#39;son&#39;;
　　}
　　function index(){

　　}

　　function hello(){
　　　　echo &#39;hello&#39;;
　　}
}

?>

Execute the index method of the subclass SonAction and find that the input result is hellofather

From this we can draw the conclusion: When THINKPHP When the parent class has a constructor but the subclass does not, THINKPHP will not execute the subclass's

_initialize()

； When THINKPHP's parent class and subclasses both have constructors, it must be called The constructor of the parent class must use

parent::construct()

----------------- _initialize()Similarly; When a subclass of THINKPHP has both the

construct

constructor and the _initialize() method, only the construct constructor of the subclass will be executed (this is my Personal test, the above code does not work).

Summarize

The above is the detailed content of Detailed introduction to the difference between the constructor _construct() and _initialize() of classes in ThinkPHP. For more information, please follow other related articles on the PHP Chinese website!