traits ב-PHP: use, כמה traits ו-insteadof

trait ב-PHP הוא בלוק של מתודות ומאפיינים לשימוש חוזר. מצהירים עליו עם trait Name { ... } ומושכים אותו לכל מחלקה עם use Name; בתוך גוף המחלקה. PHP מעתיקה את החברים של ה-trait לתוך המחלקה, ולכן הם עובדים בדיוק כאילו כתבתם אותם שם.

<?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 ול-Robot אין אב משותף, ובכל זאת לשתיהן יש עכשיו hello(). traits קיימים בשביל המקרה הזה: מחלקות ב-PHP יכולות להרחיב רק מחלקה אחת, ו-trait משתף קוד הצידה, בין מחלקות שאינן קשורות.

traits עם מאפיינים

trait יכול להביא מאפיינים יחד עם המתודות שלו. המתודות משתמשות ב-$this כמו כל מתודה של המחלקה, כי ברגע שה-trait מועתק פנימה, הן מתודות של המחלקה:

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

מחלקה לא יכולה להצהיר על מאפיין עם אותו שם כמו מאפיין של trait אלא אם שתי ההצהרות זהות (אותה רמת גישה, טיפוס וערך ברירת מחדל); אחרת זו שגיאה קטלנית.

שימוש בכמה traits

רשמו כמה traits בפקודת use אחת, מופרדים בפסיקים, או כתבו כמה שורות use. המחלקה מקבלת את החברים של כולם:

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

פתרון התנגשויות עם insteadof ו-as

כששני traits מגדירים מתודה עם אותו שם, PHP מסרבת לנחש ונעצרת עם שגיאה קטלנית. בתוך בלוק use, insteadof בוחרת את המנצח, ו-as שומרת את המתודה המפסידה תחת שם אחר:

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

עם use EnglishGreeting, FrenchGreeting; פשוט ובלי בלוק, הסקריפט נעצר לפני שמשהו מודפס:

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 יכולה גם לשנות רמת גישה. use Loggable { log as protected; } הופכת את log() של ה-trait למוגנת רק במחלקה הזו, ו-use Loggable { log as private writeLog; } מוסיפה כינוי פרטי.

חברים מופשטים וסטטיים ב-trait

trait יכול לדרוש משהו מהמחלקה שמשתמשת בו על ידי הצהרה על מתודה מופשטת. יכולים להיות לו גם מתודות סטטיות ומאפיינים סטטיים. כל מחלקה שמשתמשת ב-trait מקבלת עותק משלה של מאפיין סטטי:

<?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 ו-Bike סופרות בנפרד, כי המאפיין הסטטי מועתק לכל מחלקה. זה שונה ממאפיין סטטי שמוצהר במחלקת אב משותפת, שכל הבנות חולקות; העמוד static מראה את המקרה הזה.

איזו מתודה מנצחת: מחלקה, trait או אב

אם אותו שם מתודה קיים במחלקה עצמה, ב-trait שהיא משתמשת בו ובמחלקת האב שלה, PHP בוחרת בסדר הזה: המתודה של המחלקה עצמה, אחר כך של ה-trait, אחר כך של האב. בתוך ה-trait, 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 אינו טיפוס

instanceof אף פעם לא מתאים ל-trait, ופרמטר עם טיפוס של שם trait דוחה כל אובייקט עם TypeError. כדי לשאול "האם למחלקה הזו יש את ההתנהגות", חברו את ה-trait לממשק, או בדקו את המחלקה עם 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));

הדפוס שלמעלה הוא הרגיל: הממשק Exportable הוא מה שפונקציות משתמשות בו כרמז טיפוס ומה ש-instanceof בודק, וה-trait ExportsProperties הוא מימוש מוכן שמחלקות יכולות להשתמש בו או להחליף אותו. trait לבדו הוא קוד משותף בלי חוזה; כשאתם שמים לב שאתם בודקים class_uses() בלוגיקה העסקית, ה-trait רצה ממשק לצידו. לקוד שמשותף למשפחה של מחלקות קשורות, מחלקה מופשטת עשויה להיות הבחירה הפשוטה יותר.