Detailed graphic and text explanation of how to apply traits in PHP

Starting from PHP version 5.4.0, PHP 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. The

priority of attribute in Trait
When it comes to priority, There must be a reference object for comparison. The reference object here refers to the class of the Trait 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 is as follows:

Publish:: publicF public functionLog::protectF protected function

#Through the above example, we can summarize the priorities in Trait applications as follows:

1. From the current The members of the class override the trait method

2. The trait overrides the inherited method


The priority of class members is: current class>Trait>parent class

4. Insteadof and As keywords

In a 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 Multiple Traits can be referenced 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();

Execute the above code, the output result is as follows:

Log::startLog public functionCheck::parameterCheck parameter checkparamsCheck ::startLog public function

Just like the literal meaning, the insteadof keyword replaces the latter with the former, and the as keyword gives an alias to the replaced method.

When referencing Trait, the use keyword is used, and the use keyword is also used to refer to the namespace. The difference between the two is that when referencing Trait, it is used inside the class.

The above is the detailed content of Detailed graphic and text explanation of how to apply traits in PHP. For more information, please follow other related articles on the PHP Chinese website!