Kako funkcioniraju enumi u PHP 8.1+?

Question

Accepted Answer

**Enumi** (enumeracije, PHP 8.1+) definiraju tip s fiksnim skupom imenanih vrijednosti — dugo očekivana značajka koja pruža sigurnost tipova za ograničene skupove opcija (statusi, uloge, tipovi) puno bolje nego stari pristup s konstantama klase ili magic stringovima.

## Čisti enumi (samo naimenovani slučajevi)

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

Čisti enum definira naimenovane slučajeve. Korišten kao type hint, jamči samo valjane vrijednosti — eliminirajući greške od prosljeđivanja proizvoljnih stringova/integera.

## Podržani enumi (slučajevi imaju skalarnu vrijednost)

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

**Podržani enumi** povezuju svaki slučaj sa skalarnom vrijednosti (string ili int) — korisno za pohranu u bazu podataka ili serijalizaciju, s `from()`/`tryFrom()` za konverziju iz vrijednosti i `cases()` za popis svih.

## Enumi mogu imati metode i konstante

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

Enumi mogu imati metode (i implementirati interfejse), omogućavajući vam da priložite ponašanje svakom slučaju — čineći ih moćnim alatima za modeliranje domene.

## Stari način (ono što enumi zamjenjuju)

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

## Zašto je to važno

Enumi (PHP 8.1+) su važna, dugo očekivana značajka koja donosi pravu sigurnost tipova u ograničene skupove vrijednosti — i razumijevanje ih je sve važnije kako moderni PHP codebasovi ih usvajaju.

Prijeenuma su razvojni inženjeri predstavljali fiksne skupove opcija (statusi, uloge, tipovi, stanja) s konstantama klase ili raw stringovima/integerima, što nije nudilo **nikakvu sigurnost tipova** (bilo koji string je bio prihvaćen, pa su tipfeler kao `"actve"` kompajlirani bez greške i uzrokovali runtime greške) i nije bilo načina da se ograniče valjane vrijednosti.

Enumi rješavaju ovo: kao type hint, enum jamči da mogu biti proslijeđeni samo valjani slučajevi, hvataući nevaljane vrijednosti na razini tipova umjesto kao runtime greške — značajno poboljšanje sigurnosti. **Podržani enumi** (sa skalarnim vrijednostima) čisto se integriraju s bazama podataka i serijalizacijom (`from()`/`tryFrom()` za konverziju), a enumi mogu imati **metode** (prilagavajući ponašanje svakom slučaju, npr. `label()` ili `isActive()`), čineći ih moćnim za modeliranje domene.

Razumijevanje čistih naspram podržanih enuma, njihovih metoda i kako zamjenjuju starinski pristup greškama sklonom konstanti/stringovima je važno znanje za pisanje modernog, sigurnog tipova PHP — jer su enumi sada idiomatski način za modeliranje fiksnih skupova vrijednosti i široko se koriste u trenutnim framework-ima i aplikacijama, savladavanje njih odražava fluentnost s modernim PHP-om i sposobnost pisanja sigurnijeg, izrazitijeg, samoobjašnjavajućeg koda koji sprječava cijelu klasu nevaljanih-vrijednosti grešaka.