Detailed explanation of Traits and their applications in PHP

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.
 }
}

The logging operations should be the same, so the logging implementation in the Publish and Answer actions is also the same. Obviously, this violates the DRY (Don't Repeat Yourself) principle. Therefore, it is not recommended to implement it this way.

1.3. Trait

As shown:

##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.

2. Scope of Trait

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.

3. Priority of attributes in 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__ . &#39; public function&#39; . PHP_EOL;
 }
 protected function protectF()
 {
  echo __METHOD__ . &#39; protected function&#39; . PHP_EOL;
 }
}

class Question
{
 public function publicF()
 {
  echo __METHOD__ . &#39; public function&#39; . PHP_EOL;
 }
 protected function protectF()
 {
  echo __METHOD__ . &#39; protected function&#39; . PHP_EOL;
 }
}

class Publish extends Question
{
 use Log;

 public function publicF()
 {
  echo __METHOD__ . &#39; public function&#39; . 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:

1. Members from the current class override the trait's methods

2. The trait overrides the inherited methods


The priority of class members is: Current class>Trait>Parent class

4. Insteadof and As keyword

In one class, multiple Traits can be referenced. As follows:

 <?php
trait Log
{
  public function startLog()
  {
    echo __METHOD__ . &#39; public function&#39; . PHP_EOL;
  }
  protected function endLog()
  {
    echo __METHOD__ . &#39; protected function&#39; . 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__ . &#39; parameter check&#39; . $parameters . PHP_EOL;
  }

  public function startLog()
  {
    echo __METHOD__ . &#39; public function&#39; . PHP_EOL;
  }
}

trait Check
{
  public function parameterCheck($parameters)
  {
    echo __METHOD__ . &#39; parameter check&#39; . $parameters . PHP_EOL;
  }

  public function startLog()
  {
    echo __METHOD__ . &#39; public function&#39; . 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(&#39;params&#39;);
    $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内部使用的。

以上就是本文的全部内容，希望对大家的学习有所帮助。

相关推荐：

关于PHP中的trait简单介绍

PHP中trait使用方法图文详解

php的Traits属性以及基本用法

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!