PHP Traits Explained

When building PHP applications, different classes sometimes need the same functionality. For example, several classes might format dates, generate status labels, or write log messages.

Copying the same methods into multiple classes creates unnecessary duplication. PHP provides traits to solve this problem.

In this guide, you'll learn what traits are, how to use them, and how they differ from inheritance and interfaces.

What Is a Trait in PHP?

A trait is a reusable collection of methods and properties that can be included in multiple classes.

Traits are declared using the trait keyword and included inside classes using use.

Unlike regular classes, traits cannot be instantiated directly. Their purpose is to share functionality between classes.

This is particularly useful because PHP supports single class inheritance: a class can extend only one parent class, but it can use multiple traits.

Creating Your First PHP Trait

Let's create a simple trait containing a greeting method.

<?php

trait Greeter
{
    public function greet(): string
    {
        return "Hello!";
    }
}

class Customer
{
    use Greeter;
}

$customer = new Customer();

echo $customer->greet();

Output:

Hello!

Here's what happens:

• trait Greeter defines reusable functionality.
• use Greeter includes that functionality in the Customer class.
• The object can call greet() as if the method were defined directly in its class.

You can include the same trait in other classes without copying its implementation.

Practical Example: Sharing Status Formatting

Imagine you're building a learning platform containing tasks and lessons.

Both types of objects need to display a completion status, but they represent different things.

Instead of duplicating the formatting logic, we'll create a reusable trait.

Create a file named traits-example.php:

<?php

declare(strict_types=1);

// Shared formatting functionality.

trait StatusFormatter
{
    protected function statusLabel(bool $completed): string
    {
        return $completed ? "Completed" : "Pending";
    }
}

// A task uses the trait.

class Task
{
    use StatusFormatter;

    public function __construct(
        private string $title,
        private bool $completed
    ) {
    }

    public function getSummary(): string
    {
        return "Task: " . $this->title
            . " - "
            . $this->statusLabel($this->completed);
    }
}

// A lesson uses the same trait.

class Lesson
{
    use StatusFormatter;

    public function __construct(
        private string $title,
        private bool $finished
    ) {
    }

    public function getSummary(): string
    {
        return "Lesson: " . $this->title
            . " - "
            . $this->statusLabel($this->finished);
    }
}

// Create objects.

$items = [
    new Task("Practice PHP", true),
    new Lesson("PHP Traits", false)
];

// Display results.

foreach ($items as $item) {
    echo "<p>" . htmlspecialchars(
        $item->getSummary(),
        ENT_QUOTES,
        "UTF-8"
    ) . "</p>";
}

Browser output:

Task: Practice PHP - Completed
Lesson: PHP Traits - Pending

The StatusFormatter trait provides one shared method, statusLabel().

Both classes use it, but each class manages its own properties and determines how to build its summary.

Notice that the trait method is protected. This allows the classes to call it internally without exposing it as a public method.

Using Multiple Traits

A single PHP class can include more than one trait.

The syntax is straightforward:

class Example
{
    use FirstTrait, SecondTrait;
}

This allows a class to combine different reusable behaviors without creating a complicated inheritance hierarchy.

However, what happens if two traits define methods with the same name?

Resolving Trait Method Conflicts

If two traits provide methods with the same name, PHP needs to know which implementation to use.

You can resolve the conflict using insteadof and as.

<?php

trait EmailAlert
{
    public function send(): string
    {
        return "Email sent.";
    }
}

trait SmsAlert
{
    public function send(): string
    {
        return "SMS sent.";
    }
}

class Notifier
{
    use EmailAlert, SmsAlert {
        EmailAlert::send insteadof SmsAlert;
        SmsAlert::send as sendSms;
    }
}

$notifier = new Notifier();

echo $notifier->send() . PHP_EOL;
echo $notifier->sendSms();

Output:

Email sent.
SMS sent.

Here:

• insteadof selects EmailAlert::send() when calling send().
• as creates an additional name, sendSms(), for the SMS implementation.

This example demonstrates method selection only; it doesn't send actual notifications.

Trait Method Precedence

PHP follows a specific order when a class, its traits, and its parent define methods with the same name.

1. A method declared directly in the current class takes precedence.
2. A method provided by a trait takes precedence over an inherited parent method.
3. An inherited method is used when neither the class nor its traits provide an overriding implementation.

This means a class can replace a trait's behavior by declaring its own method with the same name.

Traits vs Inheritance vs Interfaces

Use traits to share behavior, inheritance to model a meaningful parent-child relationship, and interfaces to define common requirements.

A class can extend a parent, implement interfaces, and use traits at the same time.

When Should You Use Traits?

Traits are useful for functionality shared across otherwise unrelated classes, such as formatting helpers, reusable logging methods, or common status operations.

Avoid turning traits into large collections of unrelated methods. Also be careful when traits depend on properties or methods that consuming classes are expected to provide, as these dependencies can make code harder to understand.

For more complex features or functionality that needs interchangeable implementations, a separate service object may be easier to maintain.

Key Takeaways

• Use trait to define reusable functionality.
• Use use inside a class to include a trait.
• Traits cannot be instantiated directly.
• One class can use multiple traits.
• Use insteadof to resolve conflicting trait methods.
• Use as to create an alias for a trait method.
• Methods declared directly in a class take precedence over trait methods.

PHP traits provide a convenient way to reuse common functionality without duplicating code or forcing unrelated classes into the same inheritance hierarchy. Used carefully, they help keep object-oriented applications organized and maintainable.