PHP 8.1 enums go beyond simple constants by enabling type-safe, expressive value sets with added behavior. 1. Backed enums associate scalar values (string/int) with cases, allowing safe casting via from() and tryFrom() and access to ->value. 2. Enums can define methods to encapsulate logic, such as isFinal() or getColor(), promoting clean, domain-specific code. 3. Pure enums are used when only case identity matters, ideal for flags or internal states. 4. Enums integrate seamlessly with match expressions for concise, safe value mapping. 5. The cases() method enables iteration over all enum instances, useful for UIs or validation. 6. Using enums as typed parameters enforces correctness and prevents invalid inputs. 7. Limitations include no native __toString() or JSON serialization, but workarounds exist. Ultimately, enums improve code quality by enforcing domain rules, reducing bugs, and enhancing clarity—making them a superior replacement for strings and constants in modern PHP applications.

PHP 8.1 introduced Enums as a first-class language feature, moving far beyond the simple constant-based workarounds developers used in earlier versions (like class constants or strings). Enums bring type safety, better autocompletion, and a more expressive way to represent a fixed set of values. But their real power lies in going beyond basic usage.

Let’s explore how PHP 8.1 enums are more than just named constants — and how you can use them effectively in modern applications.

1. Backed Enums: Enums with Scalar Values

One of the most practical features is backed enums, which allow each case to be associated with a scalar value (string or int). This makes enums ideal for mapping to database values, API responses, or configuration settings.

enum Status: string
{
    case Draft = 'draft';
    case Published = 'published';
    case Archived = 'archived';
}

You can now:

• Cast from the scalar value: Status::from('draft') (throws if invalid)
• Safely cast: Status::tryFrom('unknown') → null instead of exception
• Get the value: $status->value

This is a huge improvement over loose strings and enables safer data handling.

2. Methods Inside Enums: Adding Behavior

Enums aren’t just data — they can have methods. This lets you attach logic directly to your enum cases.

enum OrderStatus: string
{
    case Pending = 'pending';
    case Shipped = 'shipped';
    case Delivered = 'delivered';

    public function isFinal(): bool
    {
        return $this === self::Delivered;
    }

    public function getColor(): string
    {
        return match($this) {
            self::Pending => 'yellow',
            self::Shipped => 'blue',
            self::Delivered => 'green',
        };
    }
}

Now you can call:

echo $order->status->getColor(); // e.g., 'green'
if ($order->status->isFinal()) { /* ... */ }

This keeps related logic encapsulated — a key principle of good design.

3. Pure Enums: When You Don’t Need Values

If you only care about the identity of the case (not an underlying value), use a pure enum:

enum Priority
{
    case Low;
    case Medium;
    case High;
}

These are useful for configuration flags, feature toggles, or internal state tracking where the name itself is the meaning.

4. Using Enums with Match Expressions

Enums pair beautifully with PHP’s match expression, making your code concise and safe:

function getStatusLabel(OrderStatus $status): string
{
    return match($status) {
        OrderStatus::Pending => '? Awaiting processing',
        OrderStatus::Shipped => '? On the way',
        OrderStatus::Delivered => '? Delivered',
    };
}

No risk of invalid comparisons — the type system ensures only valid cases are used.

5. Iterating Over Enum Cases

PHP 8.1 allows you to iterate over all cases using the cases() static method:

foreach (Status::cases() as $status) {
    echo $status->value . "\n";
}

This is great for:

• Building dropdowns in forms
• Validating input against allowed values
• Generating documentation or API schemas

6. Enums and Type Safety in Practice

Using enums as parameter types prevents invalid values at compile time (well, runtime type checking):

function setOrderStatus(OrderStatus $status): void
{
    // $status can only be one of the defined cases
}

Compare this to:

function setOrderStatus(string $status) // could be *anything*

The enum version eliminates an entire class of bugs.

7. Caveats and Limitations

Enums aren’t perfect yet:

• No support for magic methods like __toString() directly
• Can’t extend enums (intentional — they’re meant to be closed sets)
• No native JSON serialization (yet); you’ll need to handle it manually or via libraries

But you can work around some:

public function __toString(): string
{
    return $this->value; // for backed enums
}

Final Thoughts

PHP 8.1 enums are not just "constants with names." They’re a powerful tool for:

• Enforcing domain rules
• Reducing bugs from invalid states
• Writing self-documenting, expressive code

Used wisely — especially with methods, backed values, and type hints — enums can elevate the quality and clarity of your application logic.

Basically: if you’re still using strings or constants for things like status, roles, or types, it’s time to switch to enums.

The above is the detailed content of Exploring PHP 8.1 Enums: Beyond Simple Constants. For more information, please follow other related articles on the PHP Chinese website!