PHP Enums and How to Use Them in Laravel

Introduction

PHP 8.1 introduced Enums, providing a more structured, type-safe way to define a fixed set of values. Enums offer a cleaner alternative to using constants or performing database lookups for predefined sets of values. In a Laravel application, enums can be extremely useful for model attributes, form validation, and API responses.

This article will explain PHP enums and demonstrate how to seamlessly integrate them into a Laravel project.

What Are Enums in PHP?

Enums (short for "enumerations") are a feature that allows developers to define a fixed set of possible values for a variable. This approach helps prevent invalid values from being assigned, improving both code readability and maintainability.

With enums, you can restrict a variable to a predefined set of values, making your code more predictable and easier to manage.

Defining an Enum in PHP

Here's an example of how to define a basic enum in PHP:


                                enum UserRole: string {
    case Admin = 'admin';
    case Editor = 'editor';
    case Viewer = 'viewer';
}

In this example:

UserRole is an enum with three cases: Admin, Editor, and Viewer.

The enum is a backed enum with a string type, allowing the values to be stored in a database.

Using Enums in Laravel

Laravel applications can benefit greatly from using enums, especially for database interactions, form validation, and API responses.

1. Using Enums in Models

You can use enums in Eloquent models to define attributes. Here’s how:


                                class User extends Model {
    protected $casts = [
        'role' => UserRole::class,
    ];
}

Now, when retrieving a user record, Laravel will automatically cast the role attribute to the UserRole enum:


                                $user = User::find(1);
echo $user->role->value; // Outputs: 'admin', 'editor', or 'viewer'

2. Using Enums in Form Validation

You can enforce the use of enum values in request validation. Laravel provides a simple way to validate enum values:


                                $request->validate([
    'role' => ['required', new Enum(UserRole::class)],
]);

This ensures that only valid enum values are accepted, making your validation process more robust and type-safe.

3. Using Enums in API Responses

Enums are also useful in API responses, where they can help ensure that only valid, meaningful data is returned. Here's an example of how to use enums in a JSON response:


                                return response()->json([
    'user' => [
        'name' => $user->name,
        'role' => $user->role->value,
    ]
]);

By using the value property, the response will return only the predefined roles, ensuring consistency in your API outputs.

Example of a Utility Method:

Here’s an example of an enum with a utility method:


                                enum Status: string {
    case Active = 'active';
    case Inactive = 'inactive';

    public function label(): string {
        return match($this) {
            self::Active => 'User is active',
            self::Inactive => 'User is inactive',
        };
    }
}

Usage:


                                echo Status::Active->label(); // Outputs: "User is active"

This approach allows you to encapsulate additional logic within the enum itself, making the codebase more maintainable.

Conclusion

PHP enums provide a powerful tool for enforcing type safety, improving code clarity, and reducing errors in Laravel applications. By using enums in models, form validation, and API responses, you can write more maintainable and bug-free code.

Enums also replace traditional constants, making your codebase cleaner, more readable, and easier to maintain. As Laravel continues to evolve, mastering enums will allow you to take full advantage of PHP's modern features and streamline your development workflow.