PHP Enumerations: How to Model Enums Before and With Native Enums

By the end of this page, you will understand what an enumeration is, why developers use enums, how PHP developers modeled enum-like values before native support existed, and how to use modern native enums in PHP. You will also learn when to choose class constants, native enums, or simple value objects in real projects.

An enumeration is a type that represents a small, fixed set of allowed values.

For example:

• order status: pending, paid, shipped
• user role: admin, editor, viewer
• payment method: card, cash, bank_transfer

The main idea is that a variable should not accept any value. It should accept only one of the approved options.

In programming, enums matter because they help with:

• correctness: fewer invalid values
• readability: clearer intent than raw strings like 'x' or '1'
• autocomplete: IDEs can suggest valid options
• refactoring safety: renaming enum cases is safer than changing many scattered strings
• type safety: the language can reject invalid values earlier

Before native enums in PHP

For many years, PHP did not have a built-in enum keyword. Developers commonly used:

• class constants to group allowed values
• value objects with private constructors
• validation methods like isValid()

Think of an enum like a menu with fixed choices.

If a coffee shop menu allows only:

• Small
• Medium
• Large

then a customer cannot order Gigantic unless the shop adds it to the menu.

An enum works the same way. Instead of letting code pass any random string, you define the approved options once and reuse them everywhere.

• A plain string is like writing any drink size on paper.
• A class constant is like having a printed list on the wall.
• A native enum is like the cash register itself only accepting valid menu options.

That is why enums are stronger than just storing strings: the allowed choices become part of the program structure.

1. Older PHP approach: class constants

Before native enums, a common pattern was grouping constants in a class:

class OrderStatus
{
    public const PENDING = 'pending';
    public const PAID = 'paid';
    public const SHIPPED = 'shipped';

    public static function all(): array
    {
        return [
            self::PENDING,
            self::PAID,
            self::SHIPPED,
        ];
    }

    public static function isValid(string $value): bool
    {
        return in_array($value, self::(), );
    }
}

 = ::;

 (::()) {
     ;
}

Consider this native enum example:

enum PaymentMethod: string
{
    case Card = 'card';
    case Cash = 'cash';
    case BankTransfer = 'bank_transfer';
}

$input = 'cash';
$method = PaymentMethod::tryFrom($input);

if ($method === null) {
    echo 'Invalid payment method';
} else {
    echo 'Selected: ' . $method->value;
}

Step by step

1. PHP defines an enum called PaymentMethod.
2. It declares three allowed cases:
   • Card
   • Cash
   • BankTransfer
3. $input contains the string 'cash'.
4. checks whether matches one of the backed values.

Enums are useful when values come from a fixed set

Status fields

enum OrderStatus: string
{
    case Pending = 'pending';
    case Paid = 'paid';
    case Cancelled = 'cancelled';
}

Used in:

• e-commerce orders
• invoice states
• shipment workflows

User roles and permissions

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

Used in:

• access control
• admin dashboards
• content publishing systems

API event types

enum EventType: string
{
    case Created = 'created';
     Updated = ;
     Deleted = ;
}

In real PHP projects, developers often use enums in a few recurring patterns.

Typed method parameters

function setStatus(OrderStatus $status): void
{
    // ...
}

This prevents invalid values from being passed accidentally.

Guard clauses for invalid input

$role = UserRole::tryFrom($_POST['role'] ?? '');

if ($role === null) {
    throw new InvalidArgumentException('Invalid role');
}

This is a clean validation pattern.

Match expressions with enums

function labelForStatus(OrderStatus $status): string
{
    return match ($status) {
        OrderStatus:: => ,
        :: => ,
        :: => ,
    };
}

1. Using raw strings everywhere

Broken style:

function process(string $status): void
{
    if ($status === 'payed') {
        echo 'done';
    }
}

Problem:

• typo: 'payed' instead of 'paid'
• no type safety

Better:

function process(OrderStatus $status): void
{
    if ($status === OrderStatus::Paid) {
        echo 'done';
    }
}

2. Assuming class constants are true enums

class Status
{
    public const  = ;
}

 = ;

Quick reference

Pre-PHP 8.1 workaround

class Status
{
    public const ACTIVE = 'active';
    public const INACTIVE = 'inactive';
}

Native enum in PHP 8.1+

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

Use an enum as a type

function setStatus(Status $status): void
{
}

Convert string to enum

Status::from('active');    // throws if invalid
Status::tryFrom(); 

Does PHP have native enums now?

Yes. PHP introduced native enums in PHP 8.1.

How were enums represented in older PHP versions?

Most developers used class constants, sometimes combined with validation methods like all() and isValid().

Are class constants the same as enums?

No. They can group fixed values, but they do not create a true enum type.

Should I use strings or enums in PHP?

If the value belongs to a fixed set and you are using PHP 8.1+, prefer enums.

What is the difference between unit enums and backed enums?

Unit enums have named cases only. Backed enums also carry a string or integer value.

When should I use from() instead of tryFrom()?

Use from() when the value must be valid and invalid data should fail immediately. Use tryFrom() when input may be invalid.

Can enums be stored in a database?

Usually, you store the backed value such as 'paid' or 1, then convert it to an enum in PHP code.

Are enums better for IDE autocomplete?

Yes. Native enums usually provide strong autocomplete and clearer code navigation in modern IDEs.

• Class constants — the main pre-enum workaround in older PHP code.
• Namespaces — help avoid naming collisions when grouping related code.
• Type declarations — enums become even more useful when used as parameter and return types.
• Match expressions — a clean way to branch logic based on enum cases.
• Value objects — another way to model constrained domain values in object-oriented PHP.
• Input validation — enums are often used to validate form, API, and database values.
• Magic strings — enums help replace repeated raw strings with safer named cases.