PHP Traits: use, mehrere Traits und insteadof

Ein PHP-Trait ist ein wiederverwendbarer Block aus Methoden und Eigenschaften. Du deklarierst ihn mit trait Name { ... } und bindest ihn mit use Name; im Klassenrumpf in jede Klasse ein. PHP kopiert die Member des Traits in die Klasse, sodass sie genau so funktionieren, als hättest du sie dort geschrieben.

<?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 und Robot haben keine gemeinsame Elternklasse, und trotzdem haben jetzt beide hello(). Genau für diesen Fall gibt es Traits: PHP-Klassen können nur eine Klasse erweitern, und ein Trait teilt Code seitwärts, zwischen Klassen, die nicht verwandt sind.

Traits mit Eigenschaften

Ein Trait kann neben seinen Methoden Eigenschaften mitbringen. Die Methoden verwenden $this wie jede Methode der Klasse, denn sobald der Trait hineinkopiert ist, sind sie Methoden der Klasse:

<?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";

Eine Klasse darf keine Eigenschaft mit demselben Namen wie eine Trait-Eigenschaft deklarieren, außer beide Deklarationen sind identisch (gleiche Sichtbarkeit, gleicher Typ, gleicher Standardwert); sonst ist es ein fataler Fehler.

Mehrere Traits verwenden

Führe mehrere Traits in einer use-Anweisung auf, durch Kommas getrennt, oder schreib mehrere use-Zeilen. Die Klasse bekommt die Member aller:

<?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());

Konflikte mit insteadof und as lösen

Wenn zwei Traits eine Methode mit demselben Namen definieren, weigert sich PHP zu raten und stoppt mit einem fatalen Fehler. In einem use-Block wählt insteadof den Gewinner, und as behält die unterlegene Methode unter einem anderen Namen:

<?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";

Mit einem einfachen use EnglishGreeting, FrenchGreeting; ohne Block stoppt das Skript, bevor irgendetwas ausgegeben wird:

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 kann auch die Sichtbarkeit ändern. use Loggable { log as protected; } macht das log() des Traits nur in dieser Klasse protected, und use Loggable { log as private writeLog; } fügt einen privaten Alias hinzu.

Abstrakte und statische Member in einem Trait

Ein Trait kann von der verwendenden Klasse etwas verlangen, indem er eine abstrakte Methode deklariert. Er kann auch statische Methoden und statische Eigenschaften haben. Jede Klasse, die den Trait verwendet, bekommt ihre eigene Kopie einer statischen Eigenschaft:

<?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 und Bike zählen getrennt, weil die statische Eigenschaft in jede Klasse kopiert wird. Das ist anders als bei einer statischen Eigenschaft in einer gemeinsamen Elternklasse, die sich alle Kinder teilen; die Seite zu static zeigt diesen Fall.

Welche Methode gewinnt: Klasse, Trait oder Elternklasse

Existiert derselbe Methodenname in der Klasse selbst, in einem verwendeten Trait und in ihrer Elternklasse, wählt PHP in dieser Reihenfolge: die eigene Methode der Klasse, dann die des Traits, dann die der Elternklasse. Im Trait erreicht parent:: weiterhin die Version der Elternklasse:

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

Ein Trait ist kein Typ

instanceof passt nie auf einen Trait, und ein Parameter mit einem Trait-Namen als Typ lehnt jedes Objekt mit einem TypeError ab. Um zu fragen, „ob diese Klasse das Verhalten hat“, kombinierst du den Trait mit einem Interface oder untersuchst die Klasse mit 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));

Das Muster oben ist das übliche: Das Interface Exportable ist das, was Funktionen als Typangabe verwenden und instanceof prüft, und der Trait ExportsProperties ist eine fertige Implementierung, die Klassen verwenden oder ersetzen können. Ein Trait allein ist geteilter Code ohne Vertrag; wenn du merkst, dass du class_uses() in der Geschäftslogik prüfst, wollte der Trait ein Interface neben sich. Für Code, den eine Familie verwandter Klassen teilt, ist eine abstrakte Klasse vielleicht die einfachere Wahl.