Traits are a mechanism for code reuse in single inheritance languages such as PHP. A Trait
is intended to reduce some limitations of single inheritance by
enabling a developer to reuse sets of methods freely in several
independent classes living in different class hierarchies.
A Trait is simply a group of methods that you want include within another class. A Trait, like an abstract class, cannot be instantiated on it’s own.
An example of a Trait could be:
Imagine if the
An interface is a contract that says “this object is able to do this thing”, whereas a Trait is giving the object the ability to do the thing.
For example:
This allows you to define simple Traits that are clear and concise and then mix in that functionality where appropriate.
A Trait is simply a group of methods that you want include within another class. A Trait, like an abstract class, cannot be instantiated on it’s own.
An example of a Trait could be:
trait
Sharable {
public
function
share(
$item
)
{
return
'share this item'
;
}
You could then include this Trait within other classes like this:
class
Post {
use
Sharable;
}
class
Comment {
use
Sharable;
}
How are Traits different to Abstract classes?
A Trait is different to an Abstract class (What are Abstract classes?) because they do not rely on inheritance.Imagine if the
Post
and the Comment
class had to inherit from a AbstractSocial
class. We are most likely going to want to do more than just share
posts and comments on social media websites, so we’ll probably end up
with a complicated inheritance tree like this:class AbstractValidate extends AbstractCache {} class AbstractSocial extends AbstractValidate {} class Post extends AbstractSocial {} |
How are Traits different to Interfaces?
Traits kind of look a lot like Interfaces. Both Traits and interfaces are usually simple, concise and not much use without an actual implemented class. However the difference between the two is important.An interface is a contract that says “this object is able to do this thing”, whereas a Trait is giving the object the ability to do the thing.
For example:
// Interface
interface
Sociable {
public
function
like();
public
function
share();
}
// Trait
trait
Sharable {
public
function
share(
$item
)
{
// share this item
}
}
// Class
class
Post
implements
Sociable {
use
Sharable;
public
function
like()
{
//
}
}
What are the benefits of Traits?
The benefit of using Traits is that you reduce code duplication whilst preventing complicated class inheritance that might not make sense within the context of your application.This allows you to define simple Traits that are clear and concise and then mix in that functionality where appropriate.