Hvordan fungerer enums i PHP 8.1+?

Question

Accepted Answer

**Enums** (enumerationer, PHP 8.1+) definerer en type med et fast sæt navngivne værdier — en længe ventet funktion, der giver typesikkerhed for begrænsede værdi-sæt (statuser, roller, typer) langt bedre end den gamle tilgang med klassekonstanter eller magiske strenge.

## Rene enums (kun navngivne 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
```

En ren enum definerer navngivne cases. Når den bruges som en typehint, garanterer den, at kun gyldige værdier accepteres — hvilket eliminerer fejl fra at videregive vilkårlige strenge/heltal.

## Backed enums (cases har en skalarværdi)

```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** knytter hver case til en skalar (streng eller heltal) — nyttigt for lagring i en database eller serialisering, med `from()`/`tryFrom()` til konvertering fra værdier og `cases()` til at vise alle.

## Enums kan have metoder og konstanter

```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 kan have metoder (og implementere interfaces), så du kan knyttet opførsel til hver case — hvilket gør dem til kraftfulde værktøjer til domæne-modellering.

## Den gamle måde (hvad enums erstatter)

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

## Hvorfor det betyder noget

Enums (PHP 8.1+) er en vigtig, længe ventet funktion, der bringer ordentlig typesikkerhed til begrænsede værdi-sæt — og at forstå dem bliver stadig vigtigere, efterhånden som moderne PHP-kodebaser adopter dem.

Før enums repræsenterede udvikler faste option-sæt (statuser, roller, typer, tilstande) med klassekonstanter eller råe strenge/heltal, hvilket ikke gav **nogen typesikkerhed** (enhver streng blev accepteret, så stavefejl som `"actve"` kompilerede fint og forårsagede runtime-fejl) og ingen måde at begrænse gyldige værdier.

Enums løser dette: som en typehint garanterer en enum, at kun gyldige cases kan blive videregivet, hvilket fanger ugyldige værdier på typniveauet i stedet for som runtime-fejl — en betydelig sikkerhedsforbedring. **Backed enums** (med skalarværdier) integreres rent med databaser og serialisering (`from()`/`tryFrom()` til konvertering), og enums kan have **metoder** (som knytter opførsel til hver case, f.eks. en `label()` eller `isActive()`), hvilket gør dem kraftfulde til domæne-modellering.

At forstå rene vs backed enums, deres metoder, og hvordan de erstatter den fejlbehæftet gamle konstant-/streng-tilgang er vigtig viden for at skrive moderne, typesikker PHP — da enums nu er den idiomatiske måde at modellere faste værdi-sæt på og er meget brugt i nuværende frameworks og applikationer, og at beherske dem afspejler flydende moderne PHP og evnen til at skrive sikrere, mere udtryksfuld, selv-dokumenterende kode, der forhindrer en hel klasse af ugyldige-værdi-fejl.