Traits

Introduction

Interfaces solved the problem of guaranteeing that unrelated classes share the same method signatures. But interfaces only describe what a class must do — they cannot provide any actual code. So what happens when you have a genuinely useful chunk of implemented behavior, like a `log()` method, that you want to reuse across several classes that have nothing else in common?

Since PHP classes can only extend one parent, you cannot simply create a `LoggableBase` class and have every class extend it — especially if those classes already extend something else. This is exactly the gap traits fill.

What is a Trait?

A trait is a mechanism for reusing a set of methods (and even properties) across multiple, otherwise unrelated classes. You can think of it as a chunk of class code that gets "copied and pasted" into any class that uses it, at compile time.

Defining a Trait

A trait is declared with the `trait` keyword and looks very similar to a class, except it cannot be instantiated on its own.

<?php
trait Loggable
{
    public function log(string $message): void
    {
        $timestamp = date("Y-m-d H:i:s");
        echo "[$timestamp] " . static::class . ": $message\n";
    }
}

This trait defines one reusable method, `log()`, that prints a timestamped message along with the class name it was called from.

Using a Trait in a Class

A class pulls a trait's methods into itself with the `use` keyword, written inside the class body (not to be confused with the `use` that imports namespaces).

<?php
class Order
{
    use Loggable;

    public function place(): void
    {
        $this->log("Order placed successfully.");
    }
}

$order = new Order();
$order->place();

[2026-07-26 10:30:00] Order: Order placed successfully.

The `Order` class now has a `log()` method as if it had been written directly inside the class, even though it lives in a separate, reusable trait.

Worked Example: Loggable

The real power of a trait shows when two classes with no shared ancestry both need the same behavior. Here, `Order` and `UserAccount` share nothing except the `Loggable` trait.

<?php
trait Loggable
{
    public function log(string $message): void
    {
        echo "[LOG] " . static::class . ": $message\n";
    }
}

class Order
{
    use Loggable;

    public function place(): void
    {
        $this->log("Order #1042 placed.");
    }
}

class UserAccount
{
    use Loggable;

    public function register(string $username): void
    {
        $this->log("User '$username' registered.");
    }
}

$order = new Order();
$order->place();

$user = new UserAccount();
$user->register("amol_c");

[LOG] Order: Order #1042 placed.
[LOG] UserAccount: User 'amol_c' registered.

`Order` and `UserAccount` do not extend each other or any common parent, yet both gained the exact same `log()` implementation simply by writing `use Loggable;`.

Using Multiple Traits

A class can use more than one trait at the same time, separated by commas, combining methods from each.

<?php
trait Loggable
{
    public function log(string $message): void
    {
        echo "[LOG] $message\n";
    }
}

trait Timestampable
{
    public function touch(): string
    {
        return date("Y-m-d");
    }
}

class Article
{
    use Loggable, Timestampable;
}

$article = new Article();
$article->log("Article saved on " . $article->touch());

[LOG] Article saved on 2026-07-26

Resolving Naming Conflicts

If two traits used in the same class define a method with the same name, PHP raises a fatal error unless you resolve the conflict explicitly using `insteadof` and `as` inside an `use { ... }` block.

<?php
trait Greeter
{
    public function hello(): string { return "Hello from Greeter"; }
}

trait Welcomer
{
    public function hello(): string { return "Hello from Welcomer"; }
}

class Receptionist
{
    use Greeter, Welcomer {
        Greeter::hello insteadof Welcomer;
        Welcomer::hello as welcomeMessage;
    }
}

$r = new Receptionist();
echo $r->hello() . "\n";
echo $r->welcomeMessage();

Hello from Greeter
Hello from Welcomer

Traits vs Interfaces vs Abstract Classes

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Traits give PHP a practical answer to code reuse across unrelated classes. Instead of forcing a shared parent class, a trait lets you drop a ready-made set of methods into any class that needs them.

In this lesson, you learned how to define traits, include them with `use`, combine multiple traits, and resolve naming conflicts between them. Next, you will learn about namespaces, which help you organize classes and avoid naming collisions as your codebase grows.