Cum funcționează enums în PHP 8.1+?

Question

Accepted Answer

**Enums** (enumerări, PHP 8.1+) definesc un tip cu un set fix de valori numite — o caracteristică mult-așteptată care asigură type safety pentru seturi constrânse de opțiuni (statusuri, roluri, tipuri) mult mai bine decât abordarea veche a constantelor de clasă sau string-uri magice.

## Pure enums (doar cazuri numite)

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

O enumerare pură definește cazuri numite. Folosită ca type hint, garantează doar valori valide — eliminând bug-urile din trecerea de string-uri/int-uri arbitrare.

## Backed enums (cazurile au o valoare scalară)

```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** asociază fiecare caz cu o valoare scalară (string sau int) — util pentru stocarea în bază de date sau serializare, cu `from()`/`tryFrom()` pentru conversie din valori și `cases()` pentru a lista toate.

## Enums pot avea metode și constante

```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 pot avea metode (și implementa interfețe), permițând atașarea de comportament la fiecare caz — făcând-le instrumente puternice pentru modelarea domeniului.

## Moda veche (ce înlocuiesc enums)

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

## De ce contează

Enums (PHP 8.1+) sunt o caracteristică importantă, mult-așteptată, care aduce type safety corespunzător pentru seturi constrânse de valori — și înțelegerea lor este din ce în ce mai esențială pe măsură ce codebases-urile PHP moderne le adoptă.

Înainte de enums, dezvoltatorii reprezentau seturi fixe de opțiuni (statusuri, roluri, tipuri, stări) cu constante de clasă sau string-uri/int-uri crude, care ofereau **niciun type safety** (orice string era acceptat, deci typos ca `"actve"` se compilau bine și cauzau bug-uri la runtime) și nicio modalitate de a constrânge valori valide.

Enums rezolvă asta: ca type hint, o enumerare garantează că doar cazuri valide pot fi transmise, detectând valori invalide la nivel de tip mai degrabă decât ca bug-uri la runtime — o îmbunătățire semnificativă a siguranței. **Backed enums** (cu valori scalare) se integrează curat cu bazele de date și serializare (`from()`/`tryFrom()` pentru conversie), iar enums pot avea **metode** (atașând comportament la fiecare caz, de ex. un `label()` sau `isActive()`), făcând-le puternice pentru modelarea domeniului.

Înțelegerea enum-urilor pure vs backed, a metodelor lor, și cum înlocuiesc abordarea veche, predispusă erorilor, de constante/string-uri este o cunoaștere importantă pentru scrierea PHP modern, type-safe — deoarece enum-urile sunt acum modul idiomativ de a modela seturi de valori fixe și sunt utilizate pe scară largă în framework-urile și aplicațiile curente, stăpânirea lor reflectă fluență cu PHP modern și capacitatea de a scrie cod mai sigur, mai expresiv, auto-documentat care previne o clasă întreagă de bug-uri de valori invalide.