This article mainly introduces Traits and their applications in PHP in detail, which has certain reference value. Interested friends can refer to it
Starting from PHP version 5.4.0, PHP It provides a new concept of code reuse, which is Trait. Trait literally means "characteristics" and "features". We can understand that using the Trait keyword can add new characteristics to classes in PHP.
Everyone who is familiar with object-oriented knows that there are two methods of code reuse commonly used in software development: inheritance and polymorphism. In PHP, only single inheritance can be achieved. Traits avoid this. The following is a comparative explanation through a simple example.
1. Inheritance VS Polymorphism VS Trait
There are now two classes: Publish.php and Answer.php. To add LOG function to it, record the actions inside the class. There are several options:
Inheritance
Polymorphism
Trait
1.1. Inheritance
As shown:
The code structure is as follows:
// Log.php <?php Class Log { public function startLog() { // echo ... } public function endLog() { // echo ... } }
// Publish.php <?php Class Publish extends Log { } // Answer.php <?php Class Answer extends Log { }
You can see that inheritance does meet the requirements. But this violates the object-oriented principle. The relationship between operations such as Publish and Answer and Log is not the relationship between the subclass and the parent class. So it is not recommended to use it this way.
1.2. Polymorphism
As shown:
##Implementation code:
// Log.php <?php Interface Log { public function startLog(); public function endLog(); }
// Publish.php <?php Class Publish implements Log { public function startLog() { // TODO: Implement startLog() method. } public function endLog() { // TODO: Implement endLog() method. } }
// Answer.php <?php Class Answer implements Log { public function startLog() { // TODO: Implement startLog() method. } public function endLog() { // TODO: Implement endLog() method. } }
1.3. Trait
##The implementation code is as follows:
// Log.php <?php trait Log{ public function startLog() { // echo .. } public function endLog() { // echo .. } }
// Publish.php <?php class Publish { use Log; } $publish = new Publish(); $publish->startLog(); $publish->endLog();
// Answer.php <?php class Answer { use Log; } $answer = new Answer(); $answer->startLog(); $answer->endLog();
As you can see, we have achieved code reuse without increasing the complexity of the code.
1.4. Conclusion
Although the inheritance method can also solve the problem, its idea goes against the object-oriented approach. The principle seems very crude; the polymorphic method is also feasible, but it does not comply with the DRY principle in software development and increases maintenance costs. The Trait method avoids the above shortcomings and achieves code reuse relatively elegantly.
After understanding the benefits of Trait, we also need to understand the rules in its implementation. Let’s talk about it first. Scope. This is easier to prove. The implementation code is as follows:
<?php class Publish { use Log; public function doPublish() { $this->publicF(); $this->protectF(); $this->privateF(); } } $publish = new Publish(); $publish->doPublish();
The output result of executing the above code is as follows:
public functionprotected functionprivate function
It can be found that the scope of Trait is visible inside the Trait class that references it. It can be understood that the use keyword copies the implementation code of the Trait into the class that references the Trait.
When it comes to priority, there must be a reference for comparison, here is the reference The object refers to the Trait's class and its parent class.
Use the following code to prove the priority of attributes in the Trait application:
<?php trait Log { public function publicF() { echo __METHOD__ . ' public function' . PHP_EOL; } protected function protectF() { echo __METHOD__ . ' protected function' . PHP_EOL; } } class Question { public function publicF() { echo __METHOD__ . ' public function' . PHP_EOL; } protected function protectF() { echo __METHOD__ . ' protected function' . PHP_EOL; } } class Publish extends Question { use Log; public function publicF() { echo __METHOD__ . ' public function' . PHP_EOL; } public function doPublish() { $this->publicF(); $this->protectF(); } } $publish = new Publish(); $publish->doPublish();
The output of the above code The results are as follows:
Publish::publicF public functionLog::protectF protected function
Through the above example, it can be concluded that The priorities in Trait applications are as follows:
2. The trait overrides the inherited methods
The priority of class members is: Current class>Trait>Parent class
In one class, multiple Traits can be referenced. As follows:
<?php trait Log { public function startLog() { echo __METHOD__ . ' public function' . PHP_EOL; } protected function endLog() { echo __METHOD__ . ' protected function' . PHP_EOL; } } trait Check { public function parameterCheck($parameters) { // do sth } } class Publish extends Question { use Log,Check; public function doPublish($para) { $this->startLog(); $this->parameterCheck($para); $this->endLog(); } }
Through the above method, we can reference multiple Traits in a class. When referencing multiple Traits, it is easy to cause problems. The most common problem is what to do if there are properties or methods with the same name in two Traits? At this time, you need to use the keywords Insteadof and as. .Please see the following implementation code:
<?php trait Log { public function parameterCheck($parameters) { echo __METHOD__ . ' parameter check' . $parameters . PHP_EOL; } public function startLog() { echo __METHOD__ . ' public function' . PHP_EOL; } } trait Check { public function parameterCheck($parameters) { echo __METHOD__ . ' parameter check' . $parameters . PHP_EOL; } public function startLog() { echo __METHOD__ . ' public function' . PHP_EOL; } } class Publish { use Check, Log { Check::parameterCheck insteadof Log; Log::startLog insteadof Check; Check::startLog as csl; } public function doPublish() { $this->startLog(); $this->parameterCheck('params'); $this->csl(); } } $publish = new Publish(); $publish->doPublish();
执行上述代码,输出结果如下:
Log::startLog public function
Check::parameterCheck parameter checkparams
Check::startLog public function
就如字面意思一般,insteadof关键字用前者取代了后者,as 关键字给被取代的方法起了一个别名。
在引用Trait时,使用了use关键字,use关键字也用来引用命名空间。两者的区别在于,引用Trait时是在class内部使用的。
以上就是本文的全部内容,希望对大家的学习有所帮助。
相关推荐:
The above is the detailed content of Detailed explanation of Traits and their applications in PHP. For more information, please follow other related articles on the PHP Chinese website!