PHP Trait: use, Birden Çok Trait ve insteadof

PHP trait'i yeniden kullanılabilir bir metot ve özellik bloğudur. Onu trait Name { ... } ile tanımlar ve sınıf gövdesinin içinde use Name; ile herhangi bir sınıfa alırsınız. PHP trait'in üyelerini sınıfa kopyalar, böylece onları oraya siz yazmışsınız gibi çalışırlar.

<?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 ve Robot sınıflarının ortak bir üst sınıfı yoktur, yine de ikisinde de artık hello() vardır. Trait'ler bu durum için vardır: PHP sınıfları yalnızca bir sınıfı genişletebilir ve bir trait kodu ilişkisiz sınıflar arasında yatay olarak paylaşır.

Özellikli trait'ler

Bir trait metotlarıyla birlikte özellikler de getirebilir. Metotlar sınıfın herhangi bir metodu gibi $this kullanır, çünkü trait kopyalandıktan sonra onlar sınıfın metotlarıdır:

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

Bir sınıf, iki tanım tamamen aynı (aynı görünürlük, tür ve varsayılan değer) olmadıkça bir trait özelliğiyle aynı adda bir özellik tanımlayamaz; aksi halde bu ölümcül bir hatadır.

Birden çok trait kullanma

Tek bir use deyiminde birkaç trait'i virgülle ayırarak listeleyin ya da birkaç use satırı yazın. Sınıf hepsinin üyelerini alır:

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

Çakışmaları insteadof ve as ile çözme

İki trait aynı adla bir metot tanımladığında PHP tahmin yürütmeyi reddeder ve ölümcül bir hatayla durur. Bir use bloğunun içinde insteadof kazananı seçer, as ise kaybeden metodu başka bir adla tutar:

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

Blok olmadan düz bir use EnglishGreeting, FrenchGreeting; ile betik daha hiçbir şey yazdırılmadan durur:

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 görünürlüğü de değiştirebilir. use Loggable { log as protected; } trait'in log() metodunu yalnızca bu sınıfta protected yapar ve use Loggable { log as private writeLog; } private bir takma ad ekler.

Bir trait içindeki soyut ve statik üyeler

Bir trait, soyut bir metot tanımlayarak onu kullanan sınıftan bir şey isteyebilir. Statik metotları ve statik özellikleri de olabilir. Trait'i kullanan her sınıf statik bir özelliğin kendi kopyasını alır:

<?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 ve Bike ayrı ayrı sayar, çünkü statik özellik her sınıfa kopyalanır. Bu, tüm alt sınıfların paylaştığı ortak bir üst sınıfta tanımlanan statik bir özellikten farklıdır; static sayfası o durumu gösterir.

Hangi metot kazanır: sınıf, trait veya üst sınıf

Aynı metot adı sınıfın kendisinde, kullandığı bir trait'te ve üst sınıfında varsa PHP şu sırayla seçer: sınıfın kendi metodu, sonra trait'inki, sonra üst sınıfınki. Trait'in içinde parent:: hâlâ üst sınıfın sürümüne ulaşır:

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

Bir trait bir tür değildir

instanceof asla bir trait ile eşleşmez ve bir trait adıyla türlendirilmiş bir parametre her nesneyi bir TypeError ile reddeder. "Bu sınıf bu davranışa sahip mi" diye sormak için trait'i bir arayüzle eşleştirin ya da sınıfı class_uses() ile inceleyin:

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

Yukarıdaki kalıp olağan olanıdır: Exportable arayüzü fonksiyonların tür ipucu olarak kullandığı ve instanceof ile kontrol edilen şeydir, ExportsProperties trait'i ise sınıfların kullanabileceği veya değiştirebileceği hazır bir uygulamadır. Tek başına bir trait sözleşmesi olmayan paylaşılan koddur; iş mantığında class_uses() kontrol ettiğinizi fark ettiğinizde trait yanında bir arayüz istiyordur. İlişkili sınıflardan oluşan bir ailenin paylaştığı kod için bir soyut sınıf daha basit bir seçim olabilir.