Mastering PHP Traits: Reuse Code Efficiently with Real-World Examples

Trait is a fine‑grained code‑reuse syntax added in PHP 5.4.

Traits are a code‑reuse mechanism prepared for single‑inheritance languages like PHP. By reducing the limitations of single inheritance, traits allow developers to reuse methods across independent classes, defining a way to lower complexity and avoid the typical problems of multiple inheritance and mixins. Traits are similar to classes but are intended solely for composing functionality in a fine‑grained and consistent manner. They cannot be instantiated themselves; they add horizontal composition to traditional inheritance, meaning the involved classes do not need to inherit from each other.

What Is a Trait?

Simply put, a trait lets you extract repeated methods into a separate file and include them with the use keyword to achieve code reuse.

How should you split your code into traits? Here is one approach:

A trait, translated as “feature” or “characteristic”, represents a specific capability.

trait Sellable {
    protected $price = 0;

    public function getPrice() {
        return $this->price;
    }

    public function setPrice(int $price) {
        $this->price = $price;
    }
}

All products share common attributes such as brand, so we define a base Product class:

class Product {
    protected $brand;
    // ...
    public function __construct($brand) {
        $this->brand = $brand;
    }
    public function getBrand() {
        return $this->brand;
    }
    // ...
}

TV and Computer classes extend Product and use the Sellable trait:

class TV extends Product {
    use Sellable;
    // ...
    public function play() {
        echo "A {$this->brand} TV is playing...";
    }
    // ...
}

class Computer extends Product {
    use Sellable;
    protected $cores = 8;
    public function getNumberOfCores() {
        return $this->cores;
    }
    // ...
}

Gift items are not sellable, so they do not use the trait:

class Gift extends Product {
    protected $name;
    function __construct($brand, $name) {
        parent::__construct($brand);
        $this->name = $name;
    }
    // ...
}

Instead of creating another base class like Goods to hold price‑related logic, traits let you compose the needed functionality without deep inheritance hierarchies.

Another example: a Flyable trait could contain properties such as altitude and distance, and methods like takeOff and land.

What Are the Advantages of Traits?

Consider this class using multiple traits:

class User extends Model {
    use Authenticate, SoftDeletes, Arrayable, Cacheable;
    // ...
}

The class instantly reveals which features it supports. Contrast this with an approach that bundles all those features into a single abstract base class:

abstract class AdvansedUser {
    // ... implements Authenticate, SoftDeletes, Arrayable, Cacheable
}
class User extends AdvansedUser {
    // ...
}

To understand the capabilities you would need to read the AdvansedUser code, which reduces readability. Naming such a base class to reflect all combined features is impractical, and changing feature sets later (e.g., removing caching from a subclass) would require creating additional base classes.

In summary, traits provide a clear, low‑coupling way to compose reusable functionality.

Practical tips for designing traits:

Derive traits from requirements or functional descriptions rather than merely spotting duplicate code.

Include related properties when extracting a trait (e.g., price belongs to the “sellable” trait).

If naming a trait feels difficult, reconsider whether the split truly represents a distinct feature; a well‑designed trait can be described as “the feature that does X”.

Remember: avoid splitting code solely to eliminate duplication without a clear functional rationale.