PHP - Enumerations (Enums) in PHP

Enumerations, introduced in PHP 8.1, provide a way to define a fixed set of possible values for a variable. Before enums existed in PHP, developers often used constants or arrays to represent a group of related values, but those approaches lacked strict type safety and structure. Enums solve this by allowing you to define a custom type with a limited number of valid values.

Concept and Purpose

An enum is a special type that represents a collection of constant values. It ensures that a variable can only take one of the predefined values, reducing errors and improving code clarity. For example, instead of allowing any string to represent a user role, an enum can restrict it to specific options such as ADMIN, USER, or GUEST.

This approach improves reliability because invalid values cannot be assigned accidentally. It also enhances readability since the meaning of each value is clearly defined within the enum itself.

Basic Syntax

Enums are declared using the enum keyword. A simple enum looks like this:

enum Status {
    case Pending;
    case Approved;
    case Rejected;
}

Each case represents a possible value. You can use the enum like this:

$status = Status::Approved;

This ensures that the variable $status can only hold one of the defined cases.

Backed Enums

PHP also supports backed enums, where each enum case is associated with a scalar value such as a string or integer. This is useful when you need to store enum values in a database or interact with external systems.

Example:

enum Role: string {
    case Admin = 'admin';
    case User = 'user';
    case Guest = 'guest';
}

You can access the value like this:

echo Role::Admin->value; // outputs 'admin'

Backed enums allow conversion between enum cases and their scalar values, making them practical for real-world applications.

Methods in Enums

Enums in PHP can also contain methods, which allows you to define behavior related to the enum values.

Example:

enum OrderStatus {
    case Pending;
    case Shipped;
    case Delivered;

    public function label(): string {
        return match($this) {
            self::Pending => 'Order is pending',
            self::Shipped => 'Order has been shipped',
            self::Delivered => 'Order delivered successfully',
        };
    }
}

This allows each enum case to have associated logic, making the code more organized and object-oriented.

Enum Type Safety

One of the major advantages of enums is type safety. When a function expects an enum type, only valid enum values can be passed.

Example:

function processOrder(OrderStatus $status) {
    // process based on status
}

If an invalid value is passed, PHP will throw a type error. This prevents bugs caused by incorrect values.

Comparing Enums

Enum values can be compared directly using strict comparison:

if ($status === Status::Approved) {
    // do something
}

This comparison is safe and reliable because each enum case is a unique object.

Use Cases of Enums

Enums are widely used in scenarios where a variable should have a limited set of values. Common use cases include:

• User roles and permissions

• Order or payment statuses

• API response states

• Configuration options

They help maintain consistency across the application.

Advantages of Enums

Enums improve code quality in several ways:

• They enforce valid values through strict typing

• They make code more readable and self-explanatory

• They reduce the use of magic strings or numbers

• They allow grouping related constants in a structured way

• They support methods, enabling better encapsulation

Limitations

Enums cannot be extended like classes, and they are designed to be immutable. Once defined, their cases cannot change during runtime. This makes them predictable but less flexible in certain dynamic scenarios.

Conclusion

Enumerations in PHP provide a modern and structured way to represent fixed sets of values. They replace older patterns like constants and arrays with a more robust and type-safe approach. By using enums, developers can write cleaner, safer, and more maintainable code, especially in applications where predefined states or categories play a critical role.