PHP Traits: use, Multiple Traits and insteadof

A PHP trait is a reusable block of methods and properties. You declare it with trait Name { ... } and pull it into any class with use Name; inside the class body. PHP copies the trait's members into the class, so they work exactly as if you had written them there.

<?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 and Robot have no common parent, yet both now have hello(). Traits exist for this case: PHP classes can extend only one class, and a trait shares code sideways, between classes that are not related.

Traits with properties

A trait can bring properties along with its methods. The methods use $this like any method of the class, because once the trait is copied in, they are methods of the class:

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

A class may not declare a property with the same name as a trait property unless both declarations are identical (same visibility, type and default value); otherwise it is a fatal error.

Use multiple traits

List several traits in one use statement, separated by commas, or write several use lines. The class gets the members of all of them:

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

Resolve conflicts with insteadof and as

When two traits define a method with the same name, PHP refuses to guess and stops with a fatal error. Inside a use block, insteadof picks the winner, and as keeps the losing method under another name:

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

With a plain use EnglishGreeting, FrenchGreeting; and no block, the script stops before anything is printed:

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 can also change visibility. use Loggable { log as protected; } makes the trait's log() protected in this class only, and use Loggable { log as private writeLog; } adds a private alias.

Abstract and static members in a trait

A trait can require something from the class that uses it by declaring an abstract method. It can also have static methods and static properties. Each class that uses the trait gets its own copy of a static property:

<?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 and Bike count separately, because the static property is copied into each class. That is different from a static property declared in a shared parent class, which all children share; the static page shows that case.

Which method wins: class, trait or parent

If the same method name exists in the class itself, in a trait it uses, and in its parent class, PHP picks in this order: the class's own method, then the trait's, then the parent's. Inside the trait, parent:: still reaches the parent's version:

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

A trait is not a type

instanceof never matches a trait, and a parameter typed with a trait name rejects every object with a TypeError. To ask "does this class have the behavior", pair the trait with an interface, or inspect the class with 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));

The pattern above is the usual one: the interface Exportable is what functions type-hint and what instanceof checks, and the trait ExportsProperties is a ready-made implementation that classes can use or replace. A trait on its own is shared code with no contract; when you notice yourself checking class_uses() in business logic, the trait wanted an interface beside it. For code shared by a family of related classes, an abstract class may be the simpler choice.