Traits PHP : use, plusieurs traits et insteadof

Un trait PHP est un bloc réutilisable de méthodes et de propriétés. Vous le déclarez avec trait Name { ... } et l'importez dans n'importe quelle classe avec use Name; dans le corps de la classe. PHP copie les membres du trait dans la classe, qui fonctionnent exactement comme si vous les y aviez écrits.

<?php
trait Greets
{
    public function hello(): string
    {
        return 'Hello from ' . static::class;
    }
}

class User
{
    use Greets;
}

class Robot
{
    use Greets;
}

echo (new User())->hello(), "\n";
echo (new Robot())->hello(), "\n";

User et Robot n'ont pas de parent commun, et pourtant tous deux ont maintenant hello(). Les traits existent pour ce cas : les classes PHP ne peuvent étendre qu'une seule classe, et un trait partage du code latéralement, entre des classes sans lien.

Traits avec des propriétés

Un trait peut apporter des propriétés avec ses méthodes. Les méthodes utilisent $this comme n'importe quelle méthode de la classe, car une fois le trait copié, ce sont des méthodes de la classe :

<?php
trait HasTimestamps
{
    protected ?string $createdAt = null;
    protected ?string $updatedAt = null;

    public function touch(string $now): void
    {
        $this->createdAt ??= $now;
        $this->updatedAt = $now;
    }

    public function timestamps(): string
    {
        return "created {$this->createdAt}, updated {$this->updatedAt}";
    }
}

class Post
{
    use HasTimestamps;

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

$post = new Post('Traits in PHP');
$post->touch('2026-03-14 09:30');
$post->touch('2026-03-15 18:05');
echo $post->title, ': ', $post->timestamps(), "\n";

Une classe ne peut pas déclarer une propriété du même nom qu'une propriété du trait, sauf si les deux déclarations sont identiques (même visibilité, même type et même valeur par défaut) ; sinon c'est une erreur fatale.

Utiliser plusieurs traits

Listez plusieurs traits dans une même instruction use, séparés par des virgules, ou écrivez plusieurs lignes use. La classe reçoit les membres de tous :

<?php
trait Loggable
{
    private array $log = [];

    public function log(string $msg): void
    {
        $this->log[] = $msg;
    }

    public function history(): array
    {
        return $this->log;
    }
}

trait Sluggable
{
    public function slug(string $text): string
    {
        return trim(preg_replace('/[^a-z0-9]+/', '-', strtolower($text)), '-');
    }
}

class Article
{
    use Loggable, Sluggable;

    public function __construct(public string $title)
    {
        $this->log("created '$title'");
    }

    public function url(): string
    {
        $url = '/blog/' . $this->slug($this->title);
        $this->log("url built: $url");
        return $url;
    }
}

$a = new Article('PHP Traits, Explained!');
echo $a->url(), "\n";
print_r($a->history());

Résoudre les conflits avec insteadof et as

Quand deux traits définissent une méthode du même nom, PHP refuse de deviner et s'arrête avec une erreur fatale. Dans un bloc use, insteadof choisit le gagnant, et as garde la méthode perdante sous un autre nom :

<?php
trait EnglishGreeting
{
    public function greet(): string { return 'Hello'; }
}

trait FrenchGreeting
{
    public function greet(): string { return 'Bonjour'; }
}

class Host
{
    use EnglishGreeting, FrenchGreeting {
        EnglishGreeting::greet insteadof FrenchGreeting;
        FrenchGreeting::greet as greetFrench;
    }
}

$h = new Host();
echo $h->greet(), "\n";
echo $h->greetFrench(), "\n";

Avec un simple use EnglishGreeting, FrenchGreeting; sans bloc, le script s'arrête avant d'afficher quoi que ce soit :

PHP Fatal error:  Trait method FrenchGreeting::greet has not been applied as Host::greet, because of collision with EnglishGreeting::greet in /home/index.php on line 12

as peut aussi changer la visibilité. use Loggable { log as protected; } rend le log() du trait protégé dans cette classe seulement, et use Loggable { log as private writeLog; } ajoute un alias privé.

Membres abstraits et statiques dans un trait

Un trait peut exiger quelque chose de la classe qui l'utilise en déclarant une méthode abstraite. Il peut aussi avoir des méthodes et des propriétés statiques. Chaque classe qui utilise le trait reçoit sa propre copie d'une propriété statique :

<?php
trait CountsInstances
{
    private static int $instances = 0;

    public static function created(): int
    {
        return self::$instances;
    }

    // The using class must say what it is called
    abstract public function label(): string;

    public function register(): string
    {
        self::$instances++;
        return $this->label() . ' #' . self::$instances;
    }
}

class Car
{
    use CountsInstances;

    public function label(): string { return 'Car'; }
}

class Bike
{
    use CountsInstances;

    public function label(): string { return 'Bike'; }
}

echo (new Car())->register(), "\n";
echo (new Car())->register(), "\n";
echo (new Bike())->register(), "\n";
echo 'Cars: ', Car::created(), ', Bikes: ', Bike::created(), "\n";

Car et Bike comptent séparément, car la propriété statique est copiée dans chaque classe. C'est différent d'une propriété statique déclarée dans une classe parente commune, que tous les enfants partagent ; la page static montre ce cas.

Quelle méthode l'emporte : classe, trait ou parent

Si le même nom de méthode existe dans la classe elle-même, dans un trait qu'elle utilise et dans sa classe parente, PHP choisit dans cet ordre : la méthode propre de la classe, puis celle du trait, puis celle du parent. Dans le trait, parent:: atteint toujours la version du parent :

<?php
class Base
{
    public function hello(): string { return 'Base'; }
    public function bye(): string { return 'Base bye'; }
}

trait Friendly
{
    public function hello(): string { return 'Trait, then ' . parent::hello(); }
    public function bye(): string { return 'Trait bye'; }
}

class Child extends Base
{
    use Friendly;

    public function bye(): string { return 'Child bye'; }
}

$c = new Child();
echo $c->hello(), "\n";  // trait overrides parent
echo $c->bye(), "\n";    // class overrides trait

Un trait n'est pas un type

instanceof ne correspond jamais à un trait, et un paramètre typé avec un nom de trait rejette tout objet avec une TypeError. Pour demander « cette classe a-t-elle ce comportement », associez le trait à une interface, ou inspectez la classe avec class_uses() :

<?php
interface Exportable
{
    public function export(): array;
}

trait ExportsProperties
{
    public function export(): array
    {
        return get_object_vars($this);
    }
}

class Invoice implements Exportable
{
    use ExportsProperties;

    public function __construct(public int $id = 7, public float $total = 99.5) {}
}

$inv = new Invoice();
print_r($inv->export());

var_dump($inv instanceof Exportable);
print_r(class_uses($inv));

Le modèle ci-dessus est le modèle habituel : l'interface Exportable est ce que les fonctions utilisent comme type et ce que vérifie instanceof, et le trait ExportsProperties est une implémentation toute prête que les classes peuvent utiliser ou remplacer. Un trait seul est du code partagé sans contrat ; quand vous vous surprenez à vérifier class_uses() dans la logique métier, le trait réclamait une interface à côté de lui. Pour du code partagé par une famille de classes liées, une classe abstraite peut être le choix le plus simple.