What are Traits in PHP?

Traits in PHP are a mechanism for code reuse. They allow you to define methods in one place and reuse them in multiple classes without using inheritance.

Think of traits as a way to “copy and paste” functionality into different classes — but in a clean and maintainable way.

💡 Simple idea

Traits let you share methods between classes without forcing a parent-child relationship.

Why do we use traits?

📌 Avoid code duplication
⚙️ Reuse methods across unrelated classes
🚀 Work around PHP’s single inheritance limitation
🧠 Improve code organization

Basic trait example

PHP

trait Logger {
    public function log($message) {
        echo $message;
    }
}

class User {
    use Logger;
}

$user = new User();
$user->log("User created");

In this example, the Logger trait is reused inside the User class using the use keyword.

Multiple traits in a class

One of the biggest advantages of traits is that a class can use more than one.

PHP

trait Logger {
    public function log() {
        echo "Logging...";
    }
}

trait Notifier {
    public function notify() {
        echo "Notifying...";
    }
}

class Admin {
    use Logger, Notifier;
}

This is useful because PHP does not support multiple inheritance, but traits give a similar effect.

How traits work

Traits are not classes — you cannot instantiate them
They are included into classes using use
If methods conflict, you must resolve them manually
They behave like “code mixins”

Method conflict example

PHP

trait A {
    public function hello() {
        echo "Hello from A";
    }
}

trait B {
    public function hello() {
        echo "Hello from B";
    }
}

class Test {
    use A, B {
        B::hello insteadOf A;
    }
}

Why traits matter

🛡️ Reduce duplication in large codebases
⚙️ Improve modular design
📦 Allow flexible code reuse
👥 Help teams share functionality cleanly

📌 Real-world fact

Frameworks like Laravel use traits heavily for reusable features like authentication, logging, and notifications.

Summary

Traits in PHP are a way to reuse methods across multiple classes without using inheritance. They help keep code clean, modular, and DRY (Don’t Repeat Yourself).

In short: Traits let you share behavior across classes without inheritance limitations.