Jak fungují výčty (enums) v PHP 8.1+?

Question

Accepted Answer

**Výčty** (enumerations, PHP 8.1+) definují typ s pevnou sadou pojmenovaných hodnot — dlouho očekávaná funkce, která poskytuje typovou bezpečnost pro omezené sady možností (stavy, role, typy) daleko lépe než starý přístup pomocí konstant třídy nebo magických řetězců.

## Čisté výčty (pouze pojmenované případy)

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

Čistý výčet definuje pojmenované případy. Při použití jako type hint garantuje pouze platné hodnoty — eliminuje chyby vyplývající z předávání libovolných řetězců/celých čísel.

## Zazálohované výčty (případy mají skalární hodnotu)

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

**Zazálohované výčty** přiřazují každému případu skalární hodnotu (řetězec nebo celé číslo) — užitečné pro ukládání v databázi nebo serializaci, s `from()`/`tryFrom()` pro převod z hodnot a `cases()` pro výpis všech.

## Výčty mohou mít metody a konstanty

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

Výčty mohou mít metody (a implementovat rozhraní), což vám umožňuje připojit chování ke každému případu — což je činí výkonnými nástroji pro modelování domény.

## Starý způsob (co výčty nahrazují)

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

## Proč je to důležité

Výčty (PHP 8.1+) jsou důležitou, dlouho očekávanou funkcí, která přináší správnou typovou bezpečnost omezené sadě hodnot — a jejich pochopení je stále důležitější, protože moderní PHP kódové základny je přijímají.

Před výčty vývojáři reprezentovali pevné sady možností (stavy, role, typy, stavy) pomocí konstant třídy nebo syrových řetězců/celých čísel, což neposkytovalo **žádnou typovou bezpečnost** (byl přijat jakýkoli řetězec, takže překlepy jako `"actve"` byly zkompilováno bez problému a způsobily chyby za běhu) a nebylo způsob, jak omezit platné hodnoty.

Výčty to řeší: jako type hint výčet garantuje, že mohou být předány pouze platné případy, zachycuje neplatné hodnoty na úrovni typu spíše než jako chyby za běhu — významné zlepšení bezpečnosti. **Zazálohované výčty** (se skalárními hodnotami) se čistě integrují s databázemi a serializací (`from()`/`tryFrom()` pro převod), a výčty mohou mít **metody** (připojení chování ke každému případu, např. `label()` nebo `isActive()`), což z nich činí výkonný nástroj pro modelování domény.

Pochopení čistých vs zazálohovaných výčtů, jejich metod a jak nahrazují chybový starý přístup s konstantami/řetězci je důležité znalosti pro psaní moderního, typově bezpečného PHP — protože výčty jsou nyní idiomatickým způsobem, jak modelovat pevné sady hodnot, a jsou široce používány v současných rámcích a aplikacích, jejich zvládnutí odráží plynulost s moderním PHP a schopnost psát bezpečnější, expresivnější, samo-dokumentující se kód, který zabraňuje celé třídě chyb s neplatnými hodnotami.