PHP Traits: Code Reuse Without Inheritance

What is a Trait?

A trait is a mechanism for code reuse in single inheritance languages. It lets you include methods from multiple sources into a class.

<?php
namespace Vendor\Module\Trait;

trait LoggableTrait
{
    public function log(string $message): void
    {
        $class = static::class;
        error_log("[$class] $message");
    }

    public function logError(string $message): void
    {
        $this->log("ERROR: $message");
    }
}

trait CacheableTrait
{
    private ?string $cacheKey = null;

    public function getCacheKey(): string
    {
        if ($this->cacheKey === null) {
            $this->cacheKey = $this->generateCacheKey();
        }
        return $this->cacheKey;
    }

    abstract protected function generateCacheKey(): string;

    public function clearCache(): void
    {
        $this->cacheKey = null;
    }
}

// Use traits in a class
class ProductService
{
    use LoggableTrait;
    use CacheableTrait;

    public function createProduct(array $data): void
    {
        $this->log('Creating product: ' . $data['name']);
        // ... create product
        $this->log('Product created successfully');
    }

    protected function generateCacheKey(): string
    {
        return 'product_service_' . md5(serialize($data));
    }
}

// Usage
$service = new ProductService();
$service->createProduct(['name' => 'Widget']);
// Logs: [Vendor\Module\Model\ProductService] Creating product: Widget
echo $service->getCacheKey(); // 'product_service_...'

Traits with Properties

<?php
trait TimestampTrait
{
    protected ?\DateTimeImmutable $createdAt = null;
    protected ?\DateTimeImmutable $updatedAt = null;

    public function setCreatedAt(): void
    {
        $this->createdAt = new \DateTimeImmutable();
    }

    public function setUpdatedAt(): void
    {
        $this->updatedAt = new \DateTimeImmutable();
    }

    public function getCreatedAt(): ?\DateTimeImmutable
    {
        return $this->createdAt;
    }
}

class Article
{
    use TimestampTrait;

    public function __construct(
        public string $title,
        public string $content
    ) {
        $this->setCreatedAt();
    }
}

// Multiple classes can use the same trait
class Comment
{
    use TimestampTrait;

    public function __construct(
        public string $text
    ) {
        $this->setCreatedAt();
    }
}

Multiple Traits

<?php
trait AuditableTrait
{
    abstract protected function getAuditData(): array;

    public function audit(string $action): void
    {
        $data = $this->getAuditData();
        error_log(json_encode([
            'action' => $action,
            'class' => static::class,
            'data' => $data,
            'timestamp' => date('c')
        ]));
    }
}

trait ValidatableTrait
{
    private array $errors = [];

    public function validate(): bool
    {
        $this->errors = [];
        $this->performValidation();
        return empty($this->errors);
    }

    abstract protected function performValidation(): void;

    protected function addError(string $field, string $message): void
    {
        $this->errors[$field] = $message;
    }

    public function getErrors(): array
    {
        return $this->errors;
    }
}

// Use multiple traits
class Product
{
    use AuditableTrait, ValidatableTrait;

    public function __construct(
        private string $name,
        private float $price
    ) {}

    protected function getAuditData(): array
    {
        return ['name' => $this->name, 'price' => $this->price];
    }

    protected function performValidation(): void
    {
        if (empty($this->name)) {
            $this->addError('name', 'Name is required');
        }
        if ($this->price < 0) {
            $this->addError('price', 'Price must be positive');
        }
    }
}

$product = new Product('Widget', 29.99);
$product->audit('created');
$product->validate(); // true

Key Takeaway

Traits provide code reuse without inheritance. They can contain methods, properties, and abstract methods. A class can use multiple traits. Traits are like mixins that add behavior to classes.

Method Conflicts

When two traits define the same method name, you must resolve the conflict.

<?php
trait TraitA
{
    public function method(): string
    {
        return 'From TraitA';
    }
}

trait TraitB
{
    public function method(): string
    {
        return 'From TraitB';
    }
}

// Conflict! Which method() to use?
// class MyClass {
//     use TraitA, TraitB;
// }
// Fatal error: Conflicting method

// RESOLUTION: Use insteadof and as
trait TraitA
{
    public function method(): string
    {
        return 'From TraitA';
    }

    public function helperA(): string
    {
        return 'Helper A';
    }
}

trait TraitB
{
    public function method(): string
    {
        return 'From TraitB';
    }

    public function helperB(): string
    {
        return 'Helper B';
    }
}

class MyClass
{
    use TraitA, TraitB {
        // Use TraitA's method, exclude TraitB's
        TraitA::method insteadof TraitB;

        // Or alias TraitB's method to a different name
        TraitB::method as traitBMethod;
    }
}

$obj = new MyClass();
echo $obj->method();        // 'From TraitA'
echo $obj->traitBMethod();  // 'From TraitB'
echo $obj->helperA();       // 'Helper A'
echo $obj->helperB();       // 'Helper B'

Method Aliasing

<?php
trait LoggerTrait
{
    public function log(string $message): void
    {
        echo "Log: $message\n";
    }
}

trait DbLoggerTrait
{
    public function log(string $message): void
    {
        echo "DB Log: $message\n";
    }
}

class Service
{
    use LoggerTrait, DbLoggerTrait {
        LoggerTrait::log as consoleLog;
        DbLoggerTrait::log as dbLog;
    }

    // Now has both methods
    public function process(): void
    {
        $this->consoleLog('Processing...');  // From LoggerTrait
        $this->dbLog('Processing...');       // From DbLoggerTrait
    }
}

Abstract Methods in Traits

<?php
trait StorageTrait
{
    // Trait can require implementing class to provide this method
    abstract protected function getStorageDriver(): string;

    public function save(string $key, $value): void
    {
        $driver = $this->getStorageDriver();
        echo "Saving $key to $driver\n";
    }
}

class RedisService
{
    use StorageTrait;

    protected function getStorageDriver(): string
    {
        return 'redis';
    }
}

class DatabaseService
{
    use StorageTrait;

    protected function getStorageDriver(): string
    {
        return 'mysql';
    }
}

Visibility Modification

<?php
trait SecretTrait
{
    public function getSecret(): string
    {
        return 'secret-key-123';
    }
}

class ApiClient
{
    // Make the public trait method private in this class
    use SecretTrait {
        getSecret as private;
    }
}

$client = new ApiClient();
// $client->getSecret(); // Error: method is private

// Only accessible within the class

Key Takeaway

When traits conflict, use insteadof to pick one and as to alias. Traits can have abstract methods that the using class must implement. You can change method visibility when using a trait.

Magento's Subject Traits

Magento uses traits extensively to add common behavior to classes that can't use inheritance (because they already extend another class).

<?php
namespace Magento\Framework\View\Element\UiComponent\DataProvider\Document;

// Magento Subject trait - adds observable behavior
trait Subject
{
    private array $observers = [];

    public function attachObserver(string $event, callable $observer): void
    {
        $this->observers[$event][] = $observer;
    }

    public function notifyObservers(string $event, array $data = []): void
    {
        foreach ($this->observers[$event] ?? [] as $observer) {
            $observer($data);
        }
    }
}

// Usage in a class
class ProductDataProvider
{
    use Subject;  // Adds observer functionality

    public function saveProduct(array $data): void
    {
        // ... save product
        $this->notifyObservers('product_saved', ['product' => $data]);
    }
}

Common Magento Traits

<?php
// Trait for translation
trait TranslateTrait
{
    private \Magento\Framework\TranslateInterface $translate;

    public function setTranslate(\Magento\Framework\TranslateInterface $translate): void
    {
        $this->translate = $translate;
    }

    protected function __(string $text): string
    {
        return $this->translate->translate($text);
    }
}

// Trait for URL generation
trait UrlTrait
{
    private \Magento\Framework\UrlInterface $urlBuilder;

    public function setUrlBuilder(\Magento\Framework\UrlInterface $urlBuilder): void
    {
        $this->urlBuilder = $urlBuilder;
    }

    protected function getUrl(string $route = '', array $params = []): string
    {
        return $this->urlBuilder->getUrl($route, $params);
    }
}

// Combine multiple traits
class CustomBlock extends \Magento\Framework\View\Element\Template
{
    use TranslateTrait, UrlTrait;

    public function getWelcomeMessage(): string
    {
        return $this->__('Welcome to our store!');
    }

    public function getLoginUrl(): string
    {
        return $this->getUrl('customer/account/login');
    }
}

When to Use Traits

Practical Example: Magento-Style Trait

<?php
namespace Vendor\Module\Trait;

trait JsonSerializeTrait
{
    public function toArray(): array
    {
        return get_object_vars($this);
    }

    public function toJson(): string
    {
        return json_encode($this->toArray());
    }

    public static function fromJson(string $json): static
    {
        $data = json_decode($json, true);
        $obj = new static();
        foreach ($data as $key => $value) {
            $obj->$key = $value;
        }
        return $obj;
    }
}

trait EntityTrait
{
    protected ?int $id = null;

    public function getId(): ?int
    {
        return $this->id;
    }

    public function setId(int $id): void
    {
        $this->id = $id;
    }

    public function isNew(): bool
    {
        return $this->id === null;
    }
}

class Product
{
    use JsonSerializeTrait, EntityTrait;

    public function __construct(
        public string $name,
        public float $price
    ) {}
}

$product = new Product('Widget', 29.99);
echo $product->toJson();  // {"name":"Widget","price":29.99,"id":null}

Key Takeaway

Traits solve the problem of adding behavior to classes that already extend another class. Magento uses traits for cross-cutting concerns like translation, URL generation, and observer patterns. Use traits when composition alone isn't sufficient.