Hvordan fungerer enums i PHP 8.1+?

Question

Accepted Answer

**Enums** (enumerasjoner, PHP 8.1+) definerer en type med et fast sett av navngitte verdier — en lenge ventet funksjonalitet som gir typesikkerhet for begrenset sett med alternativer (statuser, roller, typer) langt bedre enn den gamle tilnærmingen med klassekonstanter eller magiske strenger.

## Rene enums (bare navngitte 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 navngitte cases. Brukt som en typehint, garanterer den bare gyldige verdier — og eliminerer bugger fra å sende vilkårlige strenger/heltall.

## Backed enums (cases har en skalaarverdi)

```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 skalaar (string eller int) — nyttig for lagring i en database eller serialisering, med `from()`/`tryFrom()` for å konvertere fra verdier og `cases()` for å liste alle.

## Enums kan ha 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 ha metoder (og implementere interfaces), noe som lar deg knytte atferd til hver case — som gjør dem til kraftige verktøy for domenemoding.

## Den gamle måten (hva 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 er viktig

Enums (PHP 8.1+) er en viktig, lenge ventet funksjonalitet som bringer ordentlig typesikkerhet til begrenset sett med verdier — og å forstå dem er stadig viktigere ettersom moderne PHP-kodebaser tar dem i bruk.

Før enums representerte utviklere faste alternativordninger (statuser, roller, typer, tilstander) med klassekonstanter eller rå strenger/heltall, som ga **ingen typesikkerhet** (enhver streng ble akseptert, så stavefeil som `"actve"` kompilerte fint og forårsaket runtime-bugs) og ingen måte å begrense gyldige verdier.

Enums løser dette: som en typehint garanterer en enum at bare gyldige cases kan sendes, noe som fanger ugyldige verdier på typnivå i stedet for som runtime-bugs — en betydelig sikkerhetsforbedring. **Backed enums** (med skalaarværdier) integreres rent med databaser og serialisering (`from()`/`tryFrom()` for konvertering), og enums kan ha **metoder** (knytter atferd til hver case, f.eks. en `label()` eller `isActive()`), som gjør dem kraftige for domenemoding.

Å forstå rene vs backed enums, deres metoder, og hvordan de erstatter den feilmottakelig gamle konstant-/strengtilnærmingen er viktig kunnskap for å skrive moderne, typesikker PHP — siden enums nå er den idiomatiske måten å modellere faste verdiordninger på og er mye brukt i nåværende rammeverk og applikasjoner, og å beherske dem gjenspeiler flytende bruk av moderne PHP og evnen til å skrive tryggere, mer uttrykksfull, selvdokumenterende kode som forhindrer en hel klasse med ugyldige-verdi-bugs.