Trait PHP: use, Beberapa Trait Sekaligus, dan insteadof

Trait PHP adalah blok method dan property yang bisa dipakai ulang. Kamu mendeklarasikannya dengan trait Name { ... } lalu menariknya ke class mana pun dengan use Name; di dalam badan class. PHP menyalin member trait ke dalam class, jadi semuanya bekerja persis seolah-olah kamu menulisnya langsung di sana.

<?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 dan Robot tidak punya parent yang sama, tetapi sekarang keduanya punya hello(). Trait dibuat untuk kasus seperti ini: class PHP hanya bisa meng-extend satu class, dan trait membagikan kode secara menyamping, di antara class yang tidak saling berhubungan.

Trait dengan property

Trait bisa membawa property bersama method-nya. Method-nya memakai $this seperti method lain di class itu, karena begitu trait disalin ke dalam class, method-method itu menjadi method class tersebut:

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

Class tidak boleh mendeklarasikan property dengan nama yang sama dengan property trait, kecuali kedua deklarasinya identik (visibility, tipe, dan nilai default yang sama); kalau tidak, hasilnya fatal error.

Memakai beberapa trait

Tulis beberapa trait dalam satu pernyataan use, dipisahkan koma, atau tulis beberapa baris use. Class itu mendapat member dari semuanya:

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

Mengatasi bentrok dengan insteadof dan as

Kalau dua trait mendefinisikan method dengan nama yang sama, PHP menolak untuk menebak dan berhenti dengan fatal error. Di dalam blok use, insteadof memilih pemenangnya, dan as menyimpan method yang kalah dengan nama lain:

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

Dengan use EnglishGreeting, FrenchGreeting; biasa tanpa blok, script berhenti sebelum apa pun dicetak:

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 juga bisa mengubah visibility. use Loggable { log as protected; } membuat log() milik trait itu menjadi protected hanya di class ini, dan use Loggable { log as private writeLog; } menambahkan alias private.

Member abstract dan static di trait

Trait bisa mewajibkan sesuatu dari class pemakainya dengan mendeklarasikan abstract method. Trait juga bisa punya static method dan static property. Setiap class yang memakai trait mendapat salinan static property-nya sendiri:

<?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 dan Bike menghitung secara terpisah, karena static property-nya disalin ke setiap class. Ini berbeda dengan static property yang dideklarasikan di parent class bersama, yang dipakai bersama oleh semua child-nya; halaman static menunjukkan kasus itu.

Method mana yang menang: class, trait, atau parent

Kalau nama method yang sama ada di class itu sendiri, di trait yang dipakainya, dan di parent class-nya, PHP memilih dengan urutan ini: method milik class itu sendiri, lalu milik trait, lalu milik parent. Di dalam trait, parent:: tetap bisa menjangkau versi milik 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

Trait bukan sebuah tipe

instanceof tidak pernah cocok dengan trait, dan parameter yang bertipe nama trait menolak setiap objek dengan TypeError. Untuk menanyakan "apakah class ini punya perilaku tersebut", pasangkan trait dengan interface, atau periksa class-nya dengan 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));

Pola di atas adalah pola yang umum: interface Exportable adalah yang dipakai sebagai type hint oleh fungsi dan yang diperiksa oleh instanceof, dan trait ExportsProperties adalah implementasi siap pakai yang bisa dipakai atau diganti oleh class. Trait sendirian hanyalah kode bersama tanpa kontrak; kalau kamu mendapati dirimu memeriksa class_uses() di logika bisnis, trait itu sebenarnya butuh interface di sampingnya. Untuk kode yang dipakai bersama oleh sekelompok class yang saling berhubungan, abstract class mungkin pilihan yang lebih sederhana.