Wie funktionieren Enums in PHP 8.1+?

Question

Accepted Answer

**Enums** (Enumerationen, PHP 8.1+) definieren einen Typ mit einer festen Menge benannter Werte — eine längst erwartete Funktion, die Typsicherheit für begrenzte Optionsmengen (Status, Rollen, Typen) bietet und damit die alte Herangehensweise mit Klassenkonstanten oder Magic Strings weit übertrifft.

## Pure Enums (nur benannte 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
```

Ein Pure Enum definiert benannte Cases. Als Typ-Hinweis verwendet garantiert es nur gültige Werte — wodurch Fehler durch das Übergeben willkürlicher Strings/Ints entfallen.

## Backed Enums (Cases haben einen Skalarwert)

```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** ordnen jedem Case einen Skalarwert (String oder Int) zu — nützlich zum Speichern in einer Datenbank oder zur Serialisierung, mit `from()`/`tryFrom()` zur Konvertierung von Werten und `cases()` zum Auflisten aller.

## Enums können Methoden und Konstanten haben

```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 können Methoden haben (und Interfaces implementieren), wodurch Sie Verhalten an jeden Case binden können — was sie zu leistungsstarken Domain-Modeling-Tools macht.

## Die alte Herangehensweise (was Enums ersetzen)

```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
```

## Warum es wichtig ist

Enums (PHP 8.1+) sind eine wichtige, längst erwartete Funktion, die echte Typsicherheit für begrenzte Wertmengen bringt — und ihr Verständnis ist zunehmend unverzichtbar, da moderne PHP-Codebases sie adoptieren.

Vor Enums stellten Entwickler feste Optionsmengen (Status, Rollen, Typen, Zustände) mit Klassenkonstanten oder Rohdaten (Strings/Ints) dar, was **keine Typsicherheit** bot (jeder String wurde akzeptiert, sodass Tippfehler wie `"actve"` kompilierten und Laufzeitfehler verursachten) und keine Möglichkeit, gültige Werte einzuschränken.

Enums lösen dies: Als Typ-Hinweis garantiert ein Enum, dass nur gültige Cases übergeben werden können, wodurch ungültige Werte auf Typ-Ebene statt als Laufzeitfehler abgefangen werden — eine erhebliche Sicherheitsverbesserung. **Backed Enums** (mit Skalarwerten) integrieren sich sauber mit Datenbanken und Serialisierung (`from()`/`tryFrom()` für Konvertierung), und Enums können **Methoden** haben (Verhalten an jeden Case binden, z. B. eine `label()`- oder `isActive()`-Methode), was sie zu leistungsstarken Domain-Modeling-Tools macht.

Das Verständnis von Pure vs Backed Enums, ihre Methoden und wie sie die fehleranfällige alte Konstanten-/String-Herangehensweise ersetzen, ist wichtiges Wissen zum Schreiben von modernem, typsicheren PHP — da Enums jetzt der idiomatische Weg zur Modellierung fester Wertmengen sind und in aktuellen Frameworks und Anwendungen weit verbreitet sind. Sie zu beherrschen zeigt Vertrautheit mit modernem PHP und die Fähigkeit, sicheren, ausdrucksstarken, selbstdokumentierenden Code zu schreiben, der eine ganze Klasse von Bugs durch ungültige Werte verhindert.