Trait trong PHP: use, dùng nhiều trait và insteadof

Trait trong PHP là một khối phương thức và thuộc tính dùng lại được. Bạn khai báo nó bằng trait Name { ... } và đưa nó vào bất kỳ lớp nào bằng use Name; bên trong thân lớp. PHP chép các thành viên của trait vào lớp, nên chúng chạy y hệt như khi bạn viết chúng ngay tại đó.

<?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 và Robot không có lớp cha chung, vậy mà giờ cả hai đều có hello(). Trait sinh ra cho đúng trường hợp này: lớp PHP chỉ kế thừa được từ một lớp, còn trait chia sẻ code theo chiều ngang, giữa các lớp không liên quan với nhau.

Trait có thuộc tính

Trait có thể mang theo thuộc tính cùng với phương thức. Các phương thức dùng $this như mọi phương thức khác của lớp, vì một khi trait đã được chép vào, chúng chính là phương thức của lớp:

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

Lớp không được khai báo thuộc tính trùng tên với thuộc tính của trait, trừ khi hai khai báo giống hệt nhau (cùng phạm vi truy cập, kiểu và giá trị mặc định); nếu không sẽ là lỗi nghiêm trọng (fatal error).

Dùng nhiều trait

Liệt kê nhiều trait trong một câu lệnh use, cách nhau bởi dấu phẩy, hoặc viết nhiều dòng use. Lớp sẽ nhận thành viên của tất cả các trait đó:

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

Giải quyết xung đột bằng insteadof và as

Khi hai trait định nghĩa phương thức trùng tên, PHP không đoán mà dừng lại với một lỗi nghiêm trọng. Bên trong khối use, insteadof chọn phương thức được dùng, còn as giữ phương thức kia dưới một tên khác:

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

Nếu chỉ viết use EnglishGreeting, FrenchGreeting; mà không có khối, script dừng lại trước khi in ra bất cứ thứ gì:

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 cũng đổi được phạm vi truy cập. use Loggable { log as protected; } biến log() của trait thành protected chỉ trong lớp này, còn use Loggable { log as private writeLog; } thêm một bí danh private.

Thành viên abstract và static trong trait

Trait có thể đòi hỏi lớp dùng nó phải cung cấp một thứ gì đó bằng cách khai báo phương thức abstract. Trait cũng có thể có phương thức static và thuộc tính static. Mỗi lớp dùng trait nhận một bản sao riêng của thuộc tính static:

<?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 và Bike đếm riêng, vì thuộc tính static được chép vào từng lớp. Điều này khác với thuộc tính static khai báo trong một lớp cha chung, vốn được mọi lớp con dùng chung; trang static trình bày trường hợp đó.

Phương thức nào được dùng: lớp, trait hay lớp cha

Nếu cùng một tên phương thức có trong chính lớp, trong trait mà lớp dùng và trong lớp cha, PHP chọn theo thứ tự: phương thức của chính lớp, rồi của trait, rồi của lớp cha. Bên trong trait, parent:: vẫn gọi được phiên bản của lớp cha:

<?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 không phải là một kiểu

instanceof không bao giờ khớp với trait, và một tham số khai báo kiểu bằng tên trait sẽ từ chối mọi đối tượng với lỗi TypeError. Để hỏi "lớp này có hành vi đó không", hãy ghép trait với một interface, hoặc kiểm tra lớp bằng 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));

Mẫu ở trên là cách làm thường gặp: interface Exportable là thứ các hàm khai báo kiểu và instanceof kiểm tra, còn trait ExportsProperties là phần cài đặt làm sẵn mà các lớp có thể dùng hoặc thay thế. Bản thân trait chỉ là code dùng chung, không có ràng buộc nào; khi bạn thấy mình kiểm tra class_uses() trong logic nghiệp vụ, đó là lúc trait cần một interface đi kèm. Với code dùng chung cho một nhóm lớp có liên quan, lớp trừu tượng có thể là lựa chọn đơn giản hơn.