Wat zijn traits en wanneer gebruik je ze?

Question

Accepted Answer

Een **trait** is een mechanisme voor **code-hergebruik tussen meerdere klassen** die niet gerelateerd zijn door erfenis. Omdat PHP alleen enkele erfenis toestaat, bieden traits een manier om methoden (en eigenschappen) horizontaal te delen — een vorm van "compositorische" code-hergebruik, zoals mixins.

## Het probleem dat traits oplossen

```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.
```

## Een trait definiëren en gebruiken

```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
```

Een trait is een bundel methoden/eigenschappen. Een klasse `use`t een of meer traits om hun leden **in te mengen** — ze krijgen de functionaliteit zonder van een gemeenschappelijke parent over te erven.

## Traits versus erfenis versus 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.
```

## Conflictoplossing

```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
    }
}
```

Wanneer twee traits dezelfde methode definiëren, dwingt PHP je het conflict expliciet op te lossen.

## Waarom het belangrijk is

Traits zijn een belangrijk PHP-feature voor **code-hergebruik tussen ongerelateerde klassen**, wat een echte beperking oplost: omdat PHP alleen enkele erfenis toestaat, bieden traits horizontaal hergebruik (mixins) voor het delen van gemeenschappelijke functionaliteit — logging, timestamps, soft-deletes, serializatiehelpers — tussen klassen die geen parent delen.

Het begrijpen ervan is waardevol omdat ze veel worden gebruikt in PHP-frameworks (Laravels Eloquent gebruikt traits uitgebreid voor modelgedragingen zoals `SoftDeletes`, `HasFactory`), dus je zult ze voortdurend tegenkomen en gebruiken.

Weten hoe traits verschillen van erfenis (hergebruik zonder een is-a relatie) en van interfaces (traits bieden daadwerkelijke *implementatie*/code, terwijl interfaces alleen een *contract*/handtekeningen definiëren — en de twee worden vaak gecombineerd: een interface declareert het vermogen, een trait levert de gedeelde implementatie) is sleutel tot het op de juiste manier gebruiken ervan.

Traits maken DRY, compositorische ontwerpen mogelijk die alleen erfenis niet kan, waardoor ze praktische, veel voorkomende kennis vormen voor zowel het schrijven van herbruikbare PHP-code als het begrijpen van de frameworks die eromheen zijn gebouwd. (Let op: overmatig gebruik van traits kan verbergen waar gedrag vandaan komt, dus gebruik ze voor genuine cross-cutting hergebruik, niet als standaard.)