How do enums work in PHP 8.1+?

Question

Accepted Answer

**Enums** (enumerations, PHP 8.1+) define a type with a fixed set of named values — a long-awaited feature that provides type safety for constrained sets of options (statuses, roles, types) far better than the old approach of class constants or magic strings.

## Pure enums (just named cases)

```php
<?php
enum Status {
    case Active;
    case Inactive;
    case Pending;
}

$status = Status::Active;          // a value of type Status
function setStatus(Status $s) {}    // type-safe parameter — only Status values allowed
setStatus(Status::Active);          // ✅
setStatus("active");                 // ❌ TypeError — not a Status
```

A pure enum defines named cases. Used as a type hint, it guarantees only valid values — eliminating the bugs from passing arbitrary strings/ints.

## Backed enums (cases have a scalar value)

```php
enum Status: string {              // "backed" by string values
    case Active = 'active';
    case Inactive = 'inactive';
    case Pending = 'pending';
}

Status::Active->value;              // 'active' — the backing value
Status::from('active');             // Status::Active — convert FROM the value
Status::tryFrom('bad');             // null if invalid (instead of throwing)
Status::cases();                    // [Active, Inactive, Pending] — all cases
```

**Backed enums** associate each case with a scalar (string or int) — useful for storing in a database or serializing, with `from()`/`tryFrom()` to convert from values and `cases()` to list all.

## Enums can have methods and constants

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

public function label(): string {        // methods on the enum
        return match($this) {
            Status::Active => 'Active User',
            Status::Inactive => 'Inactive User',
        };
    }
    public function isActive(): bool {
        return $this === Status::Active;
    }
}
Status::Active->label();   // "Active User"
```

Enums can have methods (and implement interfaces), letting you attach behavior to each case — making them powerful domain modeling tools.

## The old way (what enums replace)

```php
// ❌ before enums — class constants or magic strings: no type safety, typo-prone
class Status { const ACTIVE = 'active'; const INACTIVE = 'inactive'; }
function setStatus(string $s) {}   // accepts ANY string — "actve" typo compiles fine
```

## Why it matters

Enums (PHP 8.1+) are an important, long-awaited feature that brings proper type safety to constrained sets of values — and understanding them is increasingly essential as modern PHP codebases adopt them.

Before enums, developers represented fixed option sets (statuses, roles, types, states) with class constants or raw strings/ints, which offered **no type safety** (any string was accepted, so typos like `"actve"` compiled fine and caused runtime bugs) and no way to constrain valid values.

Enums solve this: as a type hint, an enum guarantees only valid cases can be passed, catching invalid values at the type level rather than as runtime bugs — a significant safety improvement. **Backed enums** (with scalar values) integrate cleanly with databases and serialization (`from()`/`tryFrom()` for conversion), and enums can have **methods** (attaching behavior to each case, e.g. a `label()` or `isActive()`), making them powerful for domain modeling.

Understanding pure vs backed enums, their methods, and how they replace the error-prone old constant/string approach is important knowledge for writing modern, type-safe PHP — since enums are now the idiomatic way to model fixed value sets and are widely used in current frameworks and applications, mastering them reflects fluency with modern PHP and the ability to write safer, more expressive, self-documenting code that prevents an entire class of invalid-value bugs.