Enums in PHP 8.1 provides a native way to define named value collections, improving code readability and type safety. 1. Use enum keyword definition to support associative scalar values ??(such as strings or integers) or pure enums; 2. Enumerations have type checks to avoid illegal values ??being passed in; 3. Provide cases() to obtain all options, tryFrom() safely converts the original value to an enum instance; 4. It does not support inheritance or direct instantiation, and pay attention to manual conversion when interacting with the database/API; 5. It is suitable for fixed value collections, and is not recommended for frequently changing values. Compared with the old version of constant simulation enumeration, PHP 8.1 enumeration reduces redundant logic and improves code structure clarity.

Enums in PHP 8.1 are a way to define a set of named values, making your code more readable and less error-prone. Before this feature, developers often used constants or classes to mimic enum behavior, but it wasn't built into the language. Now, with native support, you can create cleaner, more structured code.

What Exactly Is an Enum?

An enum (short for enumeration ) is a special kind of class that represents a fixed set of related values. For example, if you want to represent days of the week or status codes like "pending", "active", or "blocked", enums are perfect.

Here's how you define one:

 enum Status: string {
    case PENDING = 'pending';
    case ACTIVE = 'active';
    case BLOCKED = 'blocked';
}

This creates a Status type that can only be one of those three values ??— nothing else. That helps avoid bugs from typos or unexpected inputs.

Enums can also be backed (like the example above with strings or integers) or pure , meaning they don't have any associated value at all:

 enum Direction {
    case UP;
    case DOWN;
    case LEFT;
    case RIGHT;
}

In short, enums help you enforce valid values ??and make your intentions clearer in code.

Why Use Enums instead of Constants?

Before PHP 8.1, people used class constants to simulate enums:

 class Status {
    public const PENDING = 'pending';
    public const ACTIVE = 'active';
    public const BLOCKED = 'blocked';
}

But this has downsides:

• No type safety — any string could be passed where a constant was expected.
• Harder to manage when you need to validate input.
• You had to write extra logic to list possible values ??or compare them.

With enums, you get:

• Type checking — only valid cases are allowed.
• Easy comparison using === .
• Built-in methods like tryFrom() and cases() to safely convert or list values.

Enums are just a better, safer way to handle fixed sets of values.

How to Use Enums in Real Code

Let's say you're building a user system and want to handle account statuses.

Basic Usage

 function setStatus(Status $status): void {
    echo "User status is: " . $status->value;
}

setStatus(Status::ACTIVE);

If someone tries to call setStatus('random_string') , PHP will throw a type error — that's the power of enums.

Fetching All Cases

You can list all available options using cases() :

 foreach (Status::cases() as $case) {
    echo $case->name . ': ' . $case->value . PHP_EOL;
}

This prints:

 PENDING: pending
ACTIVE: active
BLOCKED: blocked

Safe Value Lookup

Use tryFrom() to convert a raw value back to an enum:

 $input = 'blocked';
$status = Status::tryFrom($input);

if ($status) {
    // do something with $status
} else {
    // invalid input
}

This avoids manual checks and reduces boilerplate.

A Few Things to Watch Out For

Enums are great, but there are a few gotchas:

• Only backed enums support tryFrom() and from() — pure enums can't map arbitrary values.
• Enums can't be extended or instantiated directly ( new Status() won't work).
• Be careful mixing enums with databases or APIs — you'll often need to convert between strings/values ??and enum types manually.

Also, while enums are powerful, don't overuse them. If a value isn't truly fixed or might change often, stick with regular variables or config files.

Basically that's it. Enums in PHP 8.1 are straightforward once you understand the basics, and they add real value by reducing errors and improving readingability.

The above is the detailed content of What are Enums in PHP 8.1?. For more information, please follow other related articles on the PHP Chinese website!