Hur fungerar enums i PHP 8.1+?

Question

Accepted Answer

**Enums** (uppräkningar, PHP 8.1+) definierar en typ med en fast uppsättning namngivna värden — en länge efterlängtad funktion som ger typsäkerhet för begränsade värdemängder (statusar, roller, typer) långt bättre än det gamla sättet att använda klasskonstanter eller magiska strängar.

## Pure enums (bara namngivna 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 pure enum definierar namngivna cases. När den används som typannotering garanteras det att bara giltiga värden används — vilket eliminerar buggar från godtyckliga strängar/heltal.

## Backed enums (cases har ett skalärvärdé)

```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** associerar varje case med ett skalärvärdé (sträng eller heltal) — användbart för lagring i databas eller serialisering, med `from()`/`tryFrom()` för konvertering från värdén och `cases()` för att lista alla.

## Enums kan ha metoder och 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 (och implementera gränssnitt), vilket låter dig fästa beteende till varje case — vilket gör dem till kraftfulla verktyg för domänmodellering.

## Det gamla sättet (vad enums ersätter)

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

## Varför det är viktigt

Enums (PHP 8.1+) är en viktig, länge efterlängtad funktion som ger ordentlig typsäkerhet till begränsade värdemängder — och att förstå dem blir allt viktigare då moderna PHP-kodbaser anammar dem.

Innan enums fanns representerade utvecklare fasta alternativuppsättningar (statusar, roller, typer, tillstånd) med klasskonstanter eller råa strängar/heltal, vilket erbjöd **ingen typsäkerhet** (vilken sträng som helst accepterades, så stavfel som `"actve"` kompilerade utan problem och orsakade körtidsbuggar) och inget sätt att begränsa giltiga värden.

Enums löser detta: som en typannotering garanterar en enum att bara giltiga cases kan skickas, vilket fångar ogiltiga värden på typnivå snarare än som körtidsbuggar — en betydande säkerhetsforbättring. **Backed enums** (med skalärvärdén) integreras smidigt med databaser och serialisering (`from()`/`tryFrom()` för konvertering), och enums kan ha **metoder** (fästa beteende till varje case, t.ex. en `label()` eller `isActive()`), vilket gör dem kraftfulla för domänmodellering.

Att förstå pure kontra backed enums, deras metoder och hur de ersätter det felbenägna gamla sättet med konstanter/strängar är viktig kunskap för att skriva modern, typsäker PHP — då enums nu är det idiomatiska sättet att modellera fasta värdemängder och är allmänt använda i moderna ramverk och applikationer, så att bemästra dem visar flytande modernt PHP och förmågan att skriva säkrare, mer uttrycksfull, själv-dokumenterad kod som förhindrar en helt klass av ogiltiga-värde-buggar.