How to Handle PHP's Backed Enums

Table Of Contents

• Implementation
• Working Solution

Implementation

You can solve value storage and serialization challenges by using backed enums with scalar values:

<?php

// String-backed enum for user status
enum UserStatus: string {
    case ACTIVE = 'active';
    case INACTIVE = 'inactive';
    case SUSPENDED = 'suspended';
    case PENDING = 'pending_verification';
    
    public function getDescription(): string {
        return match($this) {
            self::ACTIVE => 'User is active and can access all features',
            self::INACTIVE => 'User account is temporarily inactive',
            self::SUSPENDED => 'User has been suspended due to violations',
            self::PENDING => 'User account pending email verification'
        };
    }
    
    public function canLogin(): bool {
        return $this === self::ACTIVE;
    }
}

// Integer-backed enum for priority levels
enum Priority: int {
    case LOW = 1;
    case MEDIUM = 5;
    case HIGH = 10;
    case CRITICAL = 15;
    
    public static function fromImportance(string $level): self {
        return match(strtolower($level)) {
            'low', 'minor' => self::LOW,
            'medium', 'normal' => self::MEDIUM,
            'high', 'important' => self::HIGH,
            'critical', 'urgent' => self::CRITICAL,
            default => self::MEDIUM
        };
    }
}

// Database interaction
class User {
    public function __construct(
        public int $id,
        public string $name,
        public UserStatus $status
    ) {}
    
    public function toArray(): array {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'status' => $this->status->value, // Gets the backing value
            'status_description' => $this->status->getDescription()
        ];
    }
    
    public static function fromDatabase(array $data): self {
        return new self(
            $data['id'],
            $data['name'],
            UserStatus::from($data['status']) // Creates enum from value
        );
    }
}

// Usage examples
$user = new User(1, 'John Doe', UserStatus::PENDING);

// Get backing value for database storage
echo $user->status->value; // 'pending_verification'

// JSON serialization
echo json_encode($user->toArray());
// {"id":1,"name":"John Doe","status":"pending_verification","status_description":"User account pending email verification"}

// Create from database value
$userData = ['id' => 1, 'name' => 'John', 'status' => 'active'];
$dbUser = User::fromDatabase($userData);

// Type-safe comparisons
if ($dbUser->status->canLogin()) {
    echo "User can access the system";
}

// Working with integer-backed enums
$taskPriority = Priority::fromImportance('urgent');
echo $taskPriority->value; // 15

// All values and cases
foreach (UserStatus::cases() as $status) {
    echo "{$status->name}: {$status->value}\n";
}

Working Solution

Backed enums provide several powerful features:

1. Type Safety: Compile-time checking prevents invalid values
2. Database Storage: Easy conversion between enum and scalar values
3. API Serialization: Clean JSON representation with .value property
4. Validation: Built-in from() method throws exception for invalid values

Key Methods:

• $enum->value - Gets the backing value
• EnumName::from($value) - Creates enum from value (throws on invalid)
• EnumName::tryFrom($value) - Creates enum or returns null
• EnumName::cases() - Gets all enum cases

Backed enums are perfect for status fields, configuration options, and any constant that needs both type safety and persistent storage.