Enums introduced in PHP 8.1 provides a type-safe constant collection, solving the magic value problem; 1. Use enum to define fixed constants, such as Status::Draft, to ensure that only predefined values are available; 2. Bind enums to strings or integers through Backed Enums, and support from() and tryFrom() to convert between scalars and enums; 3. Enumerations can define methods and behaviors, such as color() and isEditable(), to enhance business logic encapsulation; 4. Applicable to static scenarios such as state and configuration, not for dynamic data; 5. It can implement the UnitEnum or BackedEnum interface for type constraints, improve code robustness and IDE support, which is an important feature of modern PHP development.

PHP 8.1 introduced Enums (enums) , which marked an important step forward in PHP in terms of type safety and code maintainability. In the past, we often used class constants or global constants to simulate encoded performance, but these methods lack type constraints, cannot prevent illegal values from being passed in, and it is difficult to get good prompts in the IDE. The emergence of Enums is precisely to solve these problems.

What is Enum?

Enumeration is a special data type used to define a set of named constants. In PHP 8.1, enum becomes a keyword natively supported by the language, allowing you to define a type whose value can only be one of a few predefined options.

 enum Status
{
    case Draft;
    case Published;
    case Archived;
}

Now, Status::Draft , Status::Published and Status::Archived are the only legal values. You can no longer pass strings or numbers like 'draft' or 1 at will - this greatly enhances type safety.

Improve type safety: From "magic value" to explicit types

Before there are enumerations, we often see code like this:

 function setStatus(string $status): void {
    if (!in_array($status, ['draft', 'published', 'archived'])) {
        throw new InvalidArgumentException('Invalid status');
    }
    // ...
}

The problem with this writing is:

• 'draft' is a "magic string" that is easy to spell.
• There is no compile-time check, and errors can only be found at runtime.
• The IDE cannot infer the legal value.

After using Enum:

 function setStatus(Status $status): void {
    // The type system ensures that the passed in a legal Status enum value}

// setStatus(Status::Draft);

Now, if you pass in an illegal value, PHP will directly report an error (especially when strict type is enabled), and the IDE can also provide automatic completion and error prompts.

Backed Enums: Bind scalar values

Sometimes we want the enum value to correspond to a specific string or integer (such as stored in a database). PHP 8.1 provides Backed Enums to support this.

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

You can easily convert between enum and scalar:

 // Create an enum from a string $status = OrderStatus::from('pending'); // Return OrderStatus::Pending
$status = OrderStatus::tryFrom('unknown'); // Return null (no exception thrown)

// Get the underlying value echo $status->value; // Output 'pending'

This is very practical in handling database, API requests and other scenarios - you can safely convert strings into enums, and then use type prompts to ensure the subsequent logic is correct.

Enumeration methods and behavior extensions

Enumerations can not only contain constants, but also define methods and even implement interfaces.

 enum Status
{
    case Draft;
    case Published;
    case Archived;

    public function color(): string
    {
        return match($this) {
            self::Draft => 'gray',
            self::Published => 'green',
            self::Archived => 'red',
        };
    }

    public function isEditable(): bool
    {
        return $this === self::Draft || $this === self::Published;
    }
}

Example of usage:

 echo Status::Draft->color(); // gray
var_dump(Status::Archived->isEditable()); // false

This makes enums more than just "sets of values" but can carry behavior and become part of the real domain model.

Actual suggestions and usage scenarios

• ?Status fields : Order status, article status, user role, etc.
• ?Configuration options : For example OutputFormat::Json , OutputFormat::Xml .
• ?Form input verification : Use in combination with DTO to ensure that the input values belong to a legal set.
• ? Don't abuse: If the value is dynamic (such as from the database configuration table), it is not suitable for enumeration.

Tips: You can let Enum implement UnitEnum or BackedEnum interface to do type constraints, for example:

 function processEnum(UnitEnum $enum): void { ... }

---

Summarize

PHP 8.1's Enums is not just a syntax sugar, it brings true type safety, better readability and stronger tool support. By eliminating the “magic value” and improving the robustness of the code, it is changing the way we organize constants and states.

Basically all this is it - it's not complicated, but once it's used, it can't be returned.

The above is the detailed content of PHP 8.1 Enums: A New Paradigm for Type-Safe Constants. For more information, please follow other related articles on the PHP Chinese website!