PHP 8.1 enums provide true type safety over class constants by enabling native type hints and compile-time validation. 1. Class constants lack type enforcement, allowing invalid strings to be passed. 2. Pure and backed enums (e.g., enum OrderStatus: string) ensure only valid cases are accepted, preventing type errors. 3. Use backed enums for database/API mapping, pure enums for state flags. 4. Apply best practices: strict typing, match expressions for exhaustive handling, and tryFrom() for safe input validation. 5. Enhance enums with attributes to attach metadata like labels. Migrating from constants to enums improves code safety, readability, and IDE support, making them ideal for fixed value sets like statuses or roles.

PHP has evolved significantly in recent years, and with the introduction of features like class constants, backed and pure enumerations (as of PHP 8.1), developers now have powerful tools to enforce type safety—especially when dealing with fixed sets of values. This is crucial for reducing bugs, improving code readability, and enabling better IDE support and static analysis.

Here’s how you can leverage class constants and enumerations effectively to achieve type safety in modern PHP applications.

1. Using Class Constants for Type Safety (Pre-PHP 8.1 Approach)

Before enums were introduced, a common pattern was to define related constants in a class and pair them with type hints or validation.

class OrderStatus
{
    public const PENDING = 'pending';
    public const SHIPPED = 'shipped';
    public const DELIVERED = 'delivered';
    public const CANCELLED = 'cancelled';
}

You could then use these constants across your application:

function updateStatus(string $status): void
{
    if (!in_array($status, [
        OrderStatus::PENDING,
        OrderStatus::SHIPPED,
        OrderStatus::DELIVERED,
        OrderStatus::CANCELLED,
    ], true)) {
        throw new InvalidArgumentException('Invalid status');
    }

    // Proceed with update
}

Limitations:

• No native type constraint: $status is still just a string.
• No compile-time validation.
• Easy to pass arbitrary strings that aren’t part of the allowed set.

This approach improves consistency but doesn’t provide real type safety at the language level.

2. Enums in PHP 8.1 : True Type Safety

With PHP 8.1, enumerations were introduced, allowing you to define a fixed set of named values with actual types.

Basic (Pure) Enum

enum OrderStatus: string
{
    case PENDING = 'pending';
    case SHIPPED = 'shipped';
    case DELIVERED = 'delivered';
    case CANCELLED = 'cancelled';
}

Now you can type-hint directly using the enum:

function updateStatus(OrderStatus $status): void
{
    // $status is guaranteed to be one of the defined cases
    echo "Updating to: " . $status->value;
}

Usage:

updateStatus(OrderStatus::SHIPPED); // ? Correct
updateStatus('shipped');           // ? TypeError: Expected OrderStatus, got string

This is true type safety: only valid enum cases can be passed.

Backed Enums for Scalar Mapping

The OrderStatus above is a backed enum (it has a : string backing type), meaning each case maps to a scalar value. You can also create pure enums without a backing value (useful for state-like flags):

enum Priority
{
    case LOW;
    case MEDIUM;
    case HIGH;
}

Even without scalar values, you still get type safety when passing Priority::HIGH, etc.

3. Best Practices for Type-Safe Code with Enums

To fully benefit from enums and avoid common pitfalls:

• ? Always use enums over string/int constants when representing a fixed set of options.
• ? Prefer backed enums when you need to persist values (e.g., in a database or API).
• ? Use strict typing (declare(strict_types=1);) to ensure type checks are enforced.
• ? Leverage match expressions for safe, exhaustive handling:

function getStatusLabel(OrderStatus $status): string
{
    return match ($status) {
        OrderStatus::PENDING => 'Awaiting shipment',
        OrderStatus::SHIPPED => 'On the way',
        OrderStatus::DELIVERED => 'Delivered',
        OrderStatus::CANCELLED => 'Order cancelled',
    };
}

• ? Validate input early when hydrating from external sources:

$status = OrderStatus::tryFrom($_POST['status']) 
    ?? throw new InvalidArgumentException('Invalid status');

4. Combining Enums with Attributes (PHP 8 ) for Metadata

You can enhance enums with attributes to attach metadata (e.g., labels, colors, permissions):

#[Attribute]
class Label
{
    public function __construct(public string $text) { }
}

enum Priority
{
    #[Label('Low Priority')]
    case LOW;

    #[Label('Medium Priority')]
    case MEDIUM;

    #[Label('High Priority')]
    case HIGH;

    public function label(): string
    {
        $reflector = new \ReflectionEnumCase(self::class, $this->name);
        $attribute = $reflector->getAttributes(Label::class)[0] ?? null;
        return $attribute?->newInstance()->text ?? $this->name;
    }
}

Now Priority::HIGH->label() returns 'High Priority'.

Final Thoughts

While class constants helped organize values, they lacked real type enforcement. Enums in PHP 8.1 close that gap, offering:

• Compile-time (or runtime) type safety
• Exhaustive case handling via match
• Interoperability with databases and APIs via ->value
• IDE autocompletion and refactoring support

For new projects, favor enums over class constants whenever you're modeling a finite set of options. The result is cleaner, safer, and more maintainable code.

Basically, if you're still using string constants for statuses, roles, or types—consider upgrading to enums. It's not just a syntax improvement; it's a real step toward robust, self-documenting PHP.

The above is the detailed content of Achieving Type Safety with PHP Class Constants and Enumerations. For more information, please follow other related articles on the PHP Chinese website!