Using Enums in PHP: Interfaces, Traits, Attributes, and Best Practices

Let's start with the basics. An enumeration (Enum) is a special data type that lets you define a set of named constants, each representing a specific value a variable may take, thereby improving readability and reducing errors.

The article assumes readers are already familiar with creating enums.

Interface

In PHP, enums are similar to classes, making it easy to create enums that implement interfaces. This similarity allows developers to apply their existing knowledge of classes and interfaces without a steep learning curve.

enum UserRole: string implements FilterInterface {
   case ADMIN = 'admin';

   public function applyFilter(): void
   {
        // TODO: implement applyFilter() method.
   }
}

Traits

By using traits, you can further enrich the functionality of enums.

enum UserRole: string implements FilterInterface {
   use FilterTrait;

   case ADMIN = 'admin';
}

Attributes

PHP 8.1 introduced attributes, which, when combined with enums, greatly enhance flexibility and robustness.

Creating Attributes

#[Attribute]
class Config {
   public function __construct(
       public string $displayName,
       public string $permission = ''
   ) {}
}

We apply this attribute to enum cases as a demonstration.

enum UserRole: string implements FilterInterface {
   use FilterTrait, GetsAttributes;

   #[Config(displayName: 'Administrator', permission: 'full_access')]
   case Admin = 'admin';
}

Using It in a Project?

Enum Rule

Always follow the basic rule: use enums for all possible cases.

// Bad
class Types {
    public const THEME = 'theme';
}

// Good
enum Type: string {
    case THEME = 'theme';
}

Validation Rules

Apply validation rules in requests to avoid unnecessary errors.

class CreateRequest extends FormRequest {
    public function rules(): array {
        return [
            'type' => ['required', new Enum(TypeEnum::class)],
        ];
    }

    public function getType(): TypeEnum {
        return TypeEnum::from($this->validated('type'));
    }
}

Enums as an Essential Part of Matching Mechanisms

Enums are especially useful in factory methods because IDEs can highlight unimplemented cases, simplifying debugging and error tracing.

return match ($type) {
    Type::INTRO => $this->container->make(IntroAssetContentGenerator::class),
    Type::TITLE => $this->container->make(TitleAssetContentGenerator::class),
    Type::TESTIMONIAL => $this->container->make(TestimonialsAssetContentGenerator::class),
    Type::FEATURES => $this->container->make(FeaturesAssetContentGenerator::class),
    Type::CARDS => $this->container->make(CardsAssetContentGenerator::class),
    Type::DYNAMIC_CONTENT => $this->container->make(DynamicContentAssetGenerator::class),
    Type::CAROUSEL => $this->container->make(CarouselAssetContentGenerator::class),
    Type::MEDIA => $this->container->make(MediaAssetContentGenerator::class),
};

Using Enum as Data Type

Passing enum constants instead of raw strings improves readability and reduces errors.

public function sendCode(User $user): void {
    $this->otpService->send($user, OTPTypeEnum::TYPE_EMAIL);
}

// public function send(Not $not, OTPTypeEnum $type): void

Using Enum for Casting

To avoid returning strings when retrieving model data, add enum casting.

protected $casts = [
    'type' => TypeEnum::class,
];

Optional

You can add helper methods to enums; for example, a values() method that returns an array of values, or a tryFromName() method for lookup by name.

public static function values(): array {
    return array_column(self::cases(), 'value');
}

public static function tryFromName(string $name): ?static {
    return collect(static::cases())
        ->first(fn (UnitEnum $case) => $case->name === $name);
}

Conclusion

Enums may seem simple at first, but they hold great value in PHP development. Mastering their usage and best practices enables you to write clearer, more maintainable, and less error‑prone code—so start leveraging enums in your projects today.