Come funzionano gli enum in PHP 8.1+?

Question

Accepted Answer

**Enum** (enumerazioni, PHP 8.1+) definiscono un tipo con un insieme fisso di valori denominati — una funzionalità molto attesa che fornisce type safety per insiemi di opzioni vincolate (stati, ruoli, tipi) molto meglio del vecchio approccio basato su costanti di classe o magic string.

## Pure enum (solo casi denominati)

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

Un pure enum definisce casi denominati. Utilizzato come type hint, garantisce solo valori validi — eliminando i bug derivanti dal passaggio di stringhe/interi arbitrari.

## Backed enum (i casi hanno un valore scalare)

```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 enum** associa ogni caso a uno scalare (stringa o intero) — utile per memorizzare in un database o serializzare, con `from()`/`tryFrom()` per convertire dai valori e `cases()` per elencare tutti.

## Gli enum possono avere metodi e costanti

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

Gli enum possono avere metodi (e implementare interfacce), permettendoti di allegare comportamento a ogni caso — rendendoli potenti strumenti di domain modeling.

## Il vecchio approccio (quello che gli enum sostituiscono)

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

## Perché è importante

Gli enum (PHP 8.1+) sono una funzionalità importante e molto attesa che porta una proper type safety a insiemi di valori vincolati — e comprenderli è sempre più essenziale mentre le moderne basi di codice PHP li adottano.

Prima degli enum, gli sviluppatori rappresentavano insiemi fissi di opzioni (stati, ruoli, tipi, condizioni) con costanti di classe o stringhe/interi grezzi, che offrivano **nessuna type safety** (qualsiasi stringa veniva accettata, quindi errori di battitura come `"actve"` compilavano correttamente e causavano bug a runtime) e nessun modo per vincolare i valori validi.

Gli enum risolvono questo problema: come type hint, un enum garantisce che solo casi validi possono essere passati, catturando valori non validi a livello di tipo piuttosto che come bug a runtime — un miglioramento significativo della sicurezza. **Backed enum** (con valori scalari) si integrano perfettamente con database e serializzazione (`from()`/`tryFrom()` per la conversione), e gli enum possono avere **metodi** (allegando comportamento a ogni caso, ad es. un `label()` o `isActive()`), rendendoli potenti per il domain modeling.

Comprendere gli enum puri rispetto a quelli backed, i loro metodi e come sostituiscono il vecchio approccio propenso agli errori basato su costanti/stringhe è una conoscenza importante per scrivere PHP moderno e type-safe — poiché gli enum sono ormai il modo idiomatico per modellare insiemi di valori fissi e sono ampiamente utilizzati nei framework e nelle applicazioni attuali, padroneggiarne l'uso riflette la fluidità con il PHP moderno e la capacità di scrivere codice più sicuro, più espressivo e autodocumentante che previene un'intera classe di bug relativi a valori non validi.