What are traits and when do you use them?

Question

Accepted Answer

A **trait** is a mechanism for **reusing code across multiple classes** that aren't related by inheritance. Since PHP only allows single inheritance, traits provide a way to share methods (and properties) horizontally — a form of "compositional" code reuse, like mixins.

## The problem traits solve

```text
PHP has single inheritance — a class can extend only ONE parent. But you often want
to share the SAME methods across unrelated classes (e.g. logging, timestamps).
Duplicating the code is bad; traits let you reuse it without inheritance.
```

## Defining and using a trait

```php
<?php
trait Timestampable {
    private ?DateTime $createdAt = null;

public function setCreatedAt(): void {
        $this->createdAt = new DateTime();
    }
    public function getCreatedAt(): ?DateTime {
        return $this->createdAt;
    }
}

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

// a class can USE MULTIPLE traits — their methods become part of the class
class Article {
    use Timestampable, Loggable;     // mix in BOTH traits' methods
}

$a = new Article();
$a->setCreatedAt();    // from Timestampable
$a->log("created");     // from Loggable
```

A trait is a bundle of methods/properties. A class `use`s one or more traits to **mix in** their members — gaining the functionality without inheriting from a common parent.

## Traits vs inheritance vs interfaces

```text
Inheritance (extends) → single parent, "is-a", inherits implementation
Interface → a CONTRACT (signatures only, no code), multiple allowed
Trait → reusable IMPLEMENTATION (actual code), multiple allowed, NO contract
→ Interfaces say WHAT a class can do; traits provide HOW (shared code).
  They're often used together: implement an interface, use a trait for the impl.
```

## Conflict resolution

```php
class X {
    use TraitA, TraitB {
        TraitA::hello insteadof TraitB;   // if both define hello(), pick TraitA's
        TraitB::hello as helloB;           // alias TraitB's version
    }
}
```

When two traits define the same method, PHP makes you resolve the conflict explicitly.

## Why it matters

Traits are an important PHP feature for **code reuse across unrelated classes**, solving a real limitation: since PHP allows only single inheritance, traits provide horizontal reuse (mixins) for sharing common functionality — logging, timestamps, soft-deletes, serialization helpers — across classes that don't share a parent.

Understanding them is valuable because they're widely used in PHP frameworks (Laravel's Eloquent uses traits extensively for model behaviors like `SoftDeletes`, `HasFactory`), so you'll constantly encounter and use them.

Knowing how traits differ from inheritance (reuse without an is-a relationship) and from interfaces (traits provide actual *implementation*/code, while interfaces define only a *contract*/signatures — and the two are often combined: an interface declares the capability, a trait provides the shared implementation) is key to using them appropriately.

Traits enable DRY, compositional designs that single inheritance alone can't, making them practical, frequently-encountered knowledge for both writing reusable PHP code and understanding the frameworks built around them. (The caveat: overusing traits can obscure where behavior comes from, so use them for genuine cross-cutting reuse, not as a default.)