Detailed explanation and application of Trait 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

Now there are 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

such as Picture:



The code structure is as follows:

// Log.php
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 in the figure:



Implementation code:

// Log.php
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
startLog();
$publish->endLog();
// Answer.php
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 violates the object-oriented principle and seems very crude; the polymorphic method is also feasible, However, 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. The scope of Trait
After understanding the benefits of Trait, we also need to understand the rules in its implementation. Let’s talk about scope first. This is easier to prove. The implementation code is as follows: 

publicF();
        $this->protectF();
        $this->privateF();
    }
}
$publish  = new Publish();
$publish->doPublish();
执行上述代码输出结果如下:
public function
protected function
private 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 object for comparison. The reference object here is the class that references the Trait. and its parent class. 

 Use the following code to prove the priority of attributes in Trait applications: 

publicF();
        $this->protectF();
    }
}
$publish = new Publish();
$publish->doPublish();
上述代码的输出结果如下:
Publish::publicF public function
Log::protectF protected function
Through the above example, we can summarize the priorities in Trait applications as follows: 

Members from the current class override the trait method

trait overrides the inherited method

The class member priority is:
当前类>Trait>父类



4. Insteadof and As keywords
In a class, you can reference multiple Traits, as follows:

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 
Insteadof
 and 
as
 are the two keywords. Please see the following implementation code: 

startLog();
        $this->parameterCheck('params');
        $this->csl();
    }
}
$publish = new Publish();
$publish->doPublish();
 Execute the above code and the output result is as follows: 

Log::startLog public function
Check::parameterCheck parameter checkparams
Check::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 explanation and application of Trait in PHP. For more related content, please pay attention to the PHP Chinese website (m.sbmmt.com)!