Qu'est-ce que les traits et quand les utilise-t-on ?

Question

Accepted Answer

Un **trait** est un mécanisme pour **réutiliser du code dans plusieurs classes** qui ne sont pas liées par l'héritage. Comme PHP ne permet que l'héritage simple, les traits offrent un moyen de partager des méthodes (et des propriétés) horizontalement — une forme de réutilisation de code « compositionnelle », comme les mixins.

## Le problème que les traits résolvent

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

## Définir et utiliser un 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
```

Un trait est un ensemble de méthodes/propriétés. Une classe `use` un ou plusieurs traits pour **mélanger** leurs membres — en obtenant la fonctionnalité sans hériter d'une classe parente commune.

## Traits vs héritage 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.
```

## Résolution des conflits

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

Lorsque deux traits définissent la même méthode, PHP vous oblige à résoudre le conflit explicitement.

## Pourquoi c'est important

Les traits sont une fonctionnalité PHP importante pour la **réutilisation de code entre classes non liées**, résolvant une vraie limitation : puisque PHP n'autorise que l'héritage simple, les traits fournissent la réutilisation horizontale (mixins) pour partager les fonctionnalités communes — logging, timestamps, soft-deletes, helpers de sérialisation — entre classes qui ne partagent pas un parent.

Les comprendre est utile parce qu'ils sont largement utilisés dans les frameworks PHP (Eloquent de Laravel utilise intensivement les traits pour les comportements du modèle comme `SoftDeletes`, `HasFactory`), vous les rencontrerez donc constamment et les utiliserez.

Savoir comment les traits diffèrent de l'héritage (réutilisation sans relation « is-a ») et des interfaces (les traits fournissent une véritable *implémentation*/code, tandis que les interfaces définissent seulement un *contrat*/signatures — et les deux sont souvent combinés : une interface déclare la capacité, un trait fournit l'implémentation partagée) est clé pour les utiliser correctement.

Les traits permettent des conceptions DRY et compositionnelles que l'héritage simple seul ne peut pas offrir, ce qui en fait des connaissances pratiques et fréquemment rencontrées pour écrire du code PHP réutilisable et comprendre les frameworks construits autour d'eux. (La mise en garde : abuser des traits peut obscurcir d'où vient le comportement, donc utilisez-les pour une véritable réutilisation transversale, pas par défaut.)