Traits

Reviewed & published by Brayan K

PHP classes can only inherit from one parent — but real apps often need the same behaviour (logging, timestamps, slugs) across unrelated classes. Traits are PHP's answer: reusable bundles of methods you mix into any class, no shared parent required.

Part of the free PHP course at LearnCodingFast — hands-on lessons with worked examples and the output they print, plus practice exercises and a quick quiz.

What You'll Learn in This Lesson

• Declare a trait and mix it into a class with use
• Understand how traits work around single inheritance
• Put properties and abstract methods inside a trait
• Compose several traits into one class
• Resolve method conflicts with insteadof and as
• Know when to choose a trait over an interface

1️⃣ Your First Trait

Declare a trait just like a class, but with the trait keyword. Inside it lives one or more methods. To use it, write use TraitName; at the top of a class body — PHP effectively copies the trait's methods into that class. Two completely unrelated classes can both use the same trait and gain the behaviour.

<?php
// A TRAIT is a reusable bundle of methods you can mix INTO any class.
// It solves a real problem: PHP has no multiple inheritance, but two
// unrelated classes often need the SAME behaviour.

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

// "use" pulls the trait's methods into the class, as if copy-pasted.
class Order {
    use Loggable;
}
class Invoice {
    use Loggable;
}

(new Order())->log('created');     // [Order] created
(new Invoice())->log('paid');      // [Invoice] paid
?>

2️⃣ Traits With State

Traits aren't limited to methods — they can declare properties too, and even abstract methods. When the trait is mixed in, those properties become part of the class. Inside the trait, $this refers to whatever object is using it, so the trait can read and write the host's state.

<?php
// Traits can hold PROPERTIES and abstract methods too — not just concrete code.
trait HasTimestamps {
    private ?string $createdAt = null;

    public function touch(): void {
        $this->createdAt = '2026-06-18';
    }

    public function getCreatedAt(): ?string {
        return $this->createdAt;
    }
}

class Article {
    use HasTimestamps;

    public function __construct(public string $title) {}
}

$a = new Article('Hello Traits');
echo $a->getCreatedAt() ?? 'not set';   // not set
echo "\n";
$a->touch();
echo $a->getCreatedAt();                 // 2026-06-18
?>

3️⃣ Composing Multiple Traits

A single class can use several traits at once, separated by commas (or in separate use lines). This is the real power: you build a class up from small, focused, reusable behaviours instead of one giant inheritance tree.

<?php
// A class can use SEVERAL traits at once — compose behaviour like Lego.
trait Greetable {
    public function greet(): string { return "Hi, I'm " . $this->name; }
}
trait Farewell {
    public function bye(): string { return "Bye from " . $this->name; }
}

class Person {
    public function __construct(public string $name) {}
    use Greetable, Farewell;
}

$p = new Person('Ada');
echo $p->greet() . "\n";   // Hi, I'm Ada
echo $p->bye()   . "\n";   // Bye from Ada
?>

4️⃣ Resolving Conflicts

What if two traits both define a method called log()? PHP won't guess — it raises a fatal error and asks you to choose. Inside the use block, A::method insteadof B picks the winner, and B::method as alias keeps the other version available under a new name.

<?php
// If two traits define the SAME method name, PHP raises a conflict.
// You resolve it explicitly with insteadof and (optionally) as.
trait FileLogger {
    public function log(): string { return 'to file'; }
}
trait DbLogger {
    public function log(): string { return 'to database'; }
}

class Service {
    use FileLogger, DbLogger {
        // Use FileLogger::log() as the winning log()...
        FileLogger::log insteadof DbLogger;
        // ...but keep the other under an alias.
        DbLogger::log as logToDb;
    }
}

$s = new Service();
echo $s->log()     . "\n";   // to file
echo $s->logToDb() . "\n";   // to database
?>

Now you try — fill in each ___ using the 👉 hint, then run it and check against the Output panel.

<?php
// 🎯 YOUR TURN — fill in each blank marked ___ , then run it.

trait Sluggable {
    public function slug(): string {
        return strtolower(str_replace(' ', '-', $this->title));
    }
}

class Post {
    public function __construct(public string $title) {}
    ___ Sluggable;          // 👉 the keyword that mixes a trait into a class
}

$p = new Post('Hello World');
echo $p->___() . "\n";     // 👉 the method the trait provides
                            // should print: hello-world

// ✅ Expected output:
//    hello-world
?>

🧩 Reorder Challenge

These lines define a trait, mix it into a class, and call its method — but they're scrambled. Put them in the order PHP needs.

C → B → E → A → D

The trait must be declared first: open it (C), define its method (B), close it (E). Only then can a class mix it in (A) and call the method (D), which prints pong.

🧠 Quick Recall — Predict the Output

hihi — both unrelated classes gained the same hi() method from the trait, with no shared parent.

2. Does each object keep its own state?

21 — the trait's property belongs to each instance, so $a reaches 2 and $b reaches 1 independently.

3. What happens here?

A fatal error — both traits define go(), an unresolved conflict. You must add an insteadof rule in the use block to choose a winner.

Common Errors (and the fix)

• "Trait method ... has not been applied as ... collision" — two traits define the same method. Add A::method insteadof B; in the use block.
• "Cannot instantiate trait" — you tried new SomeTrait(). Traits aren't classes; mix them into a class and instantiate that.
• "Undefined property" inside a trait — the trait references $this->name but the host class never defines it. Declare the property, or make the trait require it via an abstract method.
• A trait method clashes with one already in the class — the class's own method wins. Rename to avoid confusion, or alias the trait method with as.

Pro Tips

• 💡 Keep traits small and focused. One capability per trait (logging, timestamps) composes far better than a kitchen-sink trait.
• 💡 Pair a trait with an interface. The interface declares the contract; the trait provides a default implementation many classes can share.
• 💡 Use an abstract method in the trait to demand a piece from the host class — it documents the dependency and fails fast if it's missing.

📋 Quick Reference — Traits

Mini-Challenge: Reusable Counter Trait

No code is filled in this time — just a brief and an outline. Write it yourself, run it on onecompiler.com/php or your own machine, then check your result against the expected output in the comments.

<?php
// 🎯 MINI-CHALLENGE: a reusable "counter" trait.
// No code is filled in — work from the steps below, then run it.
//
// 1. Make a trait Countable2 with:
//       a private int $count = 0;
//       a method increment(): void that adds 1 to $count;
//       a method count(): int that returns $count.
// 2. Make TWO classes, Cart and Playlist, that each "use Countable2".
// 3. On a Cart, call increment() twice, then echo count()  -> 2
// 4. On a Playlist, call increment() once, then echo count() -> 1
//    (Each object must keep its OWN independent count.)
//
// ✅ Expected output:
//    2
//    1

// your code here
?>

🎉 Lesson Complete!

• ✅ A trait is a reusable bundle of methods mixed in with use
• ✅ Traits sidestep single inheritance — share behaviour across unrelated classes
• ✅ They can hold properties and abstract methods, not just concrete code
• ✅ A class can compose several traits at once
• ✅ Resolve clashes with insteadof and rename with as

Practice quiz

Continue this course

• Previous: Enums (PHP 8.1)
• Next: Type Declarations & Typed Properties — Add parameter, return, and property types for safer, self-documenting code
• Quick reference: PHP cheat sheet

Frequently asked questions

What's the difference between a trait and an interface in PHP?

An interface is a contract: it declares method signatures with no bodies, and a class that implements it promises to provide those methods. A trait is the opposite — it carries actual method implementations (and even properties) that get copied into the class. You reach for an interface to say 'this class can be treated as an X'; you reach for a trait to share working code across classes that can't share a common parent. They complement each other: a class often implements an interface and uses a trait that fulfils it.

Why use a trait instead of inheritance?

PHP only allows single inheritance — a class can extend exactly one parent. Traits sidestep that limit: a class can use as many traits as it likes, mixing in behaviour from several sources. They're ideal when unrelated classes need the same capability (logging, timestamps, slug generation) but don't share a meaningful is-a relationship. The rule of thumb: use inheritance for a true 'is-a' hierarchy, and a trait for a reusable 'has-this-behaviour' capability you want to bolt onto many classes.

What happens if two traits define a method with the same name?

You get a fatal conflict error unless you resolve it explicitly. Inside the use block you write A::method insteadof B; to pick which trait's version wins, and optionally B::method as otherName; to keep the loser available under a different name. This explicit resolution is intentional — PHP refuses to guess which implementation you meant, which prevents silent, hard-to-find bugs.

Can a trait have abstract methods or require properties from the class?

Yes. A trait can declare an abstract method, which forces any class using it to implement that method — a clean way to require the host class to supply a missing piece. Traits can also reference properties they expect to exist (like $this->name) or declare their own properties. This lets a trait define a 'template' of behaviour while delegating the specifics to whatever class mixes it in, similar in spirit to the template method pattern.

Related lessons

• Object-Oriented PHP