Hoe werken enums in PHP 8.1+?

Question

Accepted Answer

**Enums** (enumerations, PHP 8.1+) definiëren een type met een vaste set benoemde waarden — een lang verwachte functie die typeveiligheid biedt voor beperkte sets opties (statussen, rollen, typen) veel beter dan de oude benadering met klasseconstanten of magic strings.

## Zuivere enums (alleen benoemde 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
```

Een zuivere enum definieert benoemde cases. Gebruikt als type hint, garandeert het alleen geldige waarden — waardoor bugs van het doorgeven van willekeurige strings/ints worden geëlimineerd.

## Backed enums (cases hebben een scalaire waarde)

```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** associëren elke case met een scalaire waarde (string of int) — nuttig voor opslag in een database of serialisatie, met `from()`/`tryFrom()` om van waarden om te zetten en `cases()` om alle op te sommen.

## Enums kunnen methoden en constanten hebben

```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 kunnen methoden hebben (en interfaces implementeren), waardoor je gedrag aan elke case kunt koppelen — wat ze krachtige tools maakt voor domeinmodellering.

## De oude manier (wat enums vervangen)

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

## Waarom het belangrijk is

Enums (PHP 8.1+) zijn een belangrijke, lang verwachte functie die echte typeveiligheid brengt naar beperkte sets waarden — en het begrijpen ervan wordt steeds essentiëler nu moderne PHP-codebases ze aanvaarden.

Vóór enums stelden developers vaste optiesets (statussen, rollen, typen, toestanden) voor met klasseconstanten of ruwe strings/ints, wat **geen typeveiligheid** bood (elke string werd geaccepteerd, dus typfouten zoals `"actve"` compileerden prima en veroorzaakten runtime bugs) en geen manier om geldige waarden in te perken.

Enums lossen dit op: als type hint garandeert een enum dat alleen geldige cases kunnen worden doorgegeven, waardoor ongeldige waarden op het typniveau worden onderschept in plaats van als runtime bugs — een aanzienlijke veiligheidsverbetering. **Backed enums** (met scalaire waarden) integreren schoon met databases en serialisatie (`from()`/`tryFrom()` voor conversie), en enums kunnen **methoden** hebben (gedrag aan elke case koppelen, bijv. een `label()` of `isActive()`), waardoor ze krachtig zijn voor domeinmodellering.

Het begrijpen van zuivere enums versus backed enums, hun methoden, en hoe zij de foutgevoelige oude benadering met constanten/strings vervangen, is belangrijke kennis voor het schrijven van moderne, typeveilige PHP — aangezien enums nu de idiomatische manier zijn om vaste waardesets te modelleren en veel worden gebruikt in huidige frameworks en toepassingen, het beheersen ervan weerspiegelt vlotheid met modern PHP en het vermogen om veiliger, meer expressieve, zelf-documenterende code te schrijven die een hele klasse van bugs door ongeldige waarden voorkomt.