Using traits in PHP
Traits in PHP programming are a mechanism or process for reusing program source code in single inheritance-supported programming languages like PHP. A trait feature in a PHP class program allows programmers to define or create specific class methods that can be used by multiple PHP classes, without requiring the classes to be related through inheritance.
Sometimes programmers want to share class capabilities across multiple classes, so the trait concept is used to avoid source code repetition in the program.
What is a trait in PHP programming?
A trait in PHP programs behaves like a user-defined class, where instead of instantiating a class, the trait is used to add to an existing class’s capabilities. Traits in classes allow programmers to define methods that can be added to multiple classes, making reuse of program source code possible.
Key features of traits in the PHP language.
- Remember that traits in classes cannot self-instantiate.
- Traits cannot exist in properties, while class methods can.
- Traits in PHP allow methods to share capabilities across multiple classes.
- With PHP traits, a class can use multiple class traits.
- Remember, PHP programming does not allow multiple inheritance; meaning, a user-defined class cannot inherit from more than one class. However, with traits, a class can have multiple trait groups.
Defining and Using a Trait in PHP.
Syntax for defining a trait in PHP.
trait TraitName {
// create a Method(s) to be shared in class
public function methodName() {
echo “display the Method created for trait \n”;
}
}
How to Use a Trait in a php Class.
class ClassName {
use TraitName; //here we can add trait in the class
// add number of Other class methods and class properties
}
Example of using a trait in a PHP program.
Step 1: First define the trait in the class.
<?php
// here we define or create a trait with some class methods
trait systemLogg {
public function log($display_info) {
echo “Display Log info – ” . $display_info. “\n”;
}
public function info($display_info) {
echo “Display System Info – ” . $display_info. “\n”;
}
}
?>
Step 2: Use the trait in a user-created class.
<?php
// Define or create a class that uses the systemlog trait
class systemapps {
use systemlog; // Here we add the systemlog trait
public function run() {
$this->log(“System apps still running.”);
$this->info(“System app is workable”);
}
}
// Here we create an object of the systemapps user-created class
$sysapp = new systemapps();
$sysapp->run();
?>
Explanation of using a trait.
- In this program, the systemLogg trait creates or defines two methods: log() and systeminfo().
- Here, the systemapps class uses the systemLogg trait with the use systemLogg; statement.
- The run() method in the systemapps class calls both the log() and info() functions, which are systemLogg trait methods.
Using multiple traits in a class in PHP.
A user-created custom class in a PHP program can use multiple traits, and PHP traits will group or merge all class methods from each trait into a class. This feature can be helpful when programmers want to reuse multiple class capabilities in individual classes.
Example of using multiple traits in a PHP program.
<?php
// Here we create or define the first systemlogg class trait
trait systemLogg {
public function log($display_info) {
echo “System Log info ” . $display_info . “\n”;
}
}
// here we create or define the second indicator class trait
trait indicator {
public function indicate($display_info) {
echo “System Notify info”. $display_info. “\n”;
}
}
//here we Define a class using both class traits
class client {
use systemLog, indicator; // here we Use both systemLogg and indicator class traits
public function generateAction() {
$this->log(“client generated task.”);
$this->indicate(“You get new info.”);
}
}
// here we Create an object of the client class
$client = new client();
$client->generateAction();
?>
Explanation of using multiple traits.
- Here in this program, the client class uses both systemLogg and indicator class traits.
- In the same program, the generateAction() method calls class methods from both class traits. The systemLogg function uses the log() and indicator class methods.
Method conflicts between traits in PHP programming.
If multiple traits in a PHP program provide class methods with the same name, an error will be generated because PHP doesn’t know which class trait method to use. To resolve this condition, programmers can use method aliases or method priority.
Resolving trait method conflicts in PHP using insteadof and as.
- insteadof – If two traits in a program have class methods with the same name, this allows the programmer to indicate in the class which class method to use.
- as – This allows the programmer to give a class method a different name from a class trait, allowing the programmer to use a different name in the class.
Example of resolving method conflicts in a PHP program.
<?php
// here we Define or create the first class trait with a method
trait systemLogg {
public function log() {
echo “Display The Log message from systemLog trait \n”;
}
}
// Define the second trait with a method of the same name
trait indicator {
public function log() {
echo “Display the Log message from indicator trait \n”;
}
}
// here we Define a class using both class traits and resolving the class conflict
class systemapps {
use systemLogg, indicator {
// here it Use systemLogg’s log method instead of indicator’s
systemLogg::log instead of indicator;
// here Alias indicator’s log method as logindicator
indicator::log as logindicator;
}
public function run() {
$this->log(); //here it Calls Logger’s log
$this->logindicator(); // here it calls indicator’s log
}
}
// here we can create an object of the systemapps class
$sysapp = new systemapps();
$sysapp->run();
?>
Explanation of resolving method conflicts.
- The systemapps class uses both the systemLogg and indicator class traits, each of which has a log() method.
- The insteadof keyword is used in programs to indicate that the log() method from the systemLogg trait should be used, not the indicator one.
- The as keyword changes the log() method from the indicator trait to logindicator(), so programmers can still call it.
Attributes in PHP Programming Traits.
Traits in PHP programs can also be class properties; these must be declared as static or private, preventing programmers from self-instantiating a class trait.
Example of trait properties in a PHP program.
<?php
// Here we define or create a trait with a systemlogg property.
trait systemLogg {
private $loginfo = “this is a system log message”;
public function dispLogMessage($sysmessage) {
$this->loginfo = $sysmessage;
}
public function showLogMessage() {
return $this->loginfo;
}
}
// Define a class using the systemLogg trait.
class systemapps {
use systemLogg;
public function displayLog() {
echo $this->showLogMessage() . “\n”;
}
}
// Here we create an object of the systemapps class
$sysapp = new systemapps();
$sysapp->dispLogMessage(“fresh system log generated message”);
$sysapp->displayLog(); // Result – fresh system log generated message
?>
Explanation of Attributes in PHP Programming Traits.
- In this program, the systemLogg class trait contains a private property $logMessage and methods for manipulating properties, dispLogMessage() and showLogMessage(), generated by the class.
- The systemapps class uses the systemLogg class trait and can access properties and class methods from class attributes.
Advantages of using traits in PHP programming.
- Code reusability – Traits in a class allow programmers to reuse program source code across multiple classes without resorting to inheritance.
- Separation of concerns – Class traits help organize program source code into separate function blocks, making class programs more modular and easier to maintain.
- Avoiding inheritance problems – Class traits allow programmers to use capabilities across multiple classes without facing inheritance and class hierarchy-related issues.
A summary of trait attributes in PHP programming.
- Traits in any PHP class allow programs to reuse program source code across multiple classes without resorting to inheritance.
- A class trait contains methods and class properties that can be shared between multiple classes using the use keyword.
- A class can use multiple traits, and conflicts in declaring multiple class method names can be addressed by using the keywords method instead of and as.
- Traits in a class are especially useful in particular situations where multiple classes in a program need to share the same capabilities, even when they do not belong to the same class hierarchy.
