Switch in PHP: case, break e fallthrough

switch ($value) confronta un valore con un elenco di etichette case ed esegue il codice sotto la prima etichetta che corrisponde. Ogni case termina con break; default gestisce tutto ciò che non ha trovato corrispondenza.

<?php
$day = 'sat';

switch ($day) {
    case 'mon':
        echo "Start of the week";
        break;
    case 'fri':
        echo "Almost weekend";
        break;
    case 'sat':
    case 'sun':
        echo "Weekend";
        break;
    default:
        echo "A regular weekday";
}

Imposta $day a 'fri', 'sun' o 'wed' ed eseguilo di nuovo. Il case default non ha bisogno di break quando è l'ultimo.

Più case per un solo blocco

Per eseguire lo stesso codice per più valori, impila le etichette case senza nulla in mezzo. Un'etichetta che corrisponde prosegue nel codice sottostante.

<?php
$extension = 'jpeg';

switch ($extension) {
    case 'jpg':
    case 'jpeg':
    case 'png':
    case 'webp':
        $type = 'image';
        break;
    case 'mp4':
    case 'mov':
        $type = 'video';
        break;
    default:
        $type = 'unknown';
}

echo "Type of .$extension: $type";

A differenza di match, uno switch non ha la sintassi con la virgola case 'jpg', 'jpeg':. Le etichette impilate sono l'unico modo.

Fallthrough: cosa succede senza break

È break che ferma uno switch. Senza di esso, PHP esegue il case che corrisponde e poi continua in ogni case sottostante, ignorando le loro etichette, finché non incontra un break o la fine.

<?php
$plan = 'pro';

echo "Features for $plan:\n";
switch ($plan) {
    case 'enterprise':
        echo "- single sign-on\n";
    case 'pro':
        echo "- unlimited projects\n";
    case 'free':
        echo "- 3 projects\n";
        echo "- community support\n";
}

Qui il fallthrough è voluto: ogni piano ottiene le sue funzionalità più tutte quelle dei piani più economici. Quando lo scrivi di proposito, aggiungi un commento come // no break così chi legge dopo non lo "corregge". Quando non era voluto, un break mancante è uno dei bug più comuni negli switch.

switch usa il confronto debole (==)

Ogni case viene verificato con ==, non con ===. Una stringa numerica corrisponde a un numero, null corrisponde a false e a "", e true corrisponde a qualsiasi valore che conta come vero. Tocca le celle per confrontare i due operatori.

La conseguenza pratica: una stringa "1" arrivata da un form finisce in case 1: senza alcuna conversione, ed è spesso quello che vuoi. Ma switch (true) con una stringa non vuota, oppure null di fronte a case false:, può scegliere un case che non ti aspettavi.

<?php
function describe(mixed $value): string
{
    switch ($value) {
        case 0:
            return "zero";
        case "10":
            return "ten";
        case false:
            return "false-ish";
        default:
            return "something else";
    }
}

echo describe("0"), "\n";    // "0" == 0
echo describe(10), "\n";     // 10 == "10"
echo describe("1e1"), "\n";  // "1e1" == "10" (both are numeric)
echo describe(null), "\n";   // null == 0
echo describe(""), "\n";     // "" == false
echo describe("a"), "\n";

Nota la riga di null: non arriva mai a case false:, perché null == 0 è già vero e case 0: viene prima. Con il confronto debole, l'ordine dei case cambia il risultato. Da PHP 8, 0 == "a" è falso (in PHP 7 era vero), quindi una stringa non numerica non corrisponde più a case 0:. Se ti serve ===, usa un'espressione match, trattata alla fine di questa pagina.

switch(true) per intervalli e condizioni

Un'etichetta case può essere qualsiasi espressione. Con switch (true), ogni case è una condizione, e vince la prima che equivale a true.

<?php
$score = 83;

switch (true) {
    case $score >= 90:
        $grade = 'A';
        break;
    case $score >= 80:
        $grade = 'B';
        break;
    case $score >= 70:
        $grade = 'C';
        break;
    default:
        $grade = 'F';
}

echo "Score $score is grade $grade";

Assicurati che ogni case sia un vero booleano. A causa del confronto debole, case $name: corrisponderebbe ogni volta che $name è una stringa non vuota.

switch dentro un ciclo: break e continue

Dentro un ciclo, break in uno switch esce solo dallo switch, non dal ciclo. Per fermare il ciclo usa break 2. continue dentro uno switch si comporta come break, e PHP avvisa in fase di compilazione: "continue" targeting switch is equivalent to "break". Did you mean to use "continue 2"?. Scrivi continue 2 per passare all'iterazione successiva del ciclo.

<?php
$commands = ['add', 'skip', 'add', 'stop', 'add'];
$total = 0;

foreach ($commands as $command) {
    switch ($command) {
        case 'add':
            $total++;
            break;        // leaves the switch only
        case 'skip':
            continue 2;   // next foreach iteration
        case 'stop':
            break 2;      // leaves the foreach
    }
    echo "after $command, total = $total\n";
}

echo "Final total: $total\n";

switch vs match

PHP 8 ha aggiunto match, che copre la maggior parte degli usi di switch con meno codice. Confronta con ===, restituisce un valore, non prosegue mai nei case successivi, accetta condizioni separate da virgola e lancia un UnhandledMatchError quando nulla corrisponde, così un case dimenticato non può passare inosservato.

<?php
$status = 404;

// switch
switch ($status) {
    case 200:
    case 201:
        $text = 'OK';
        break;
    case 404:
        $text = 'Not found';
        break;
    default:
        $text = 'Error';
}
echo $text, "\n";

// match
echo match ($status) {
    200, 201 => 'OK',
    404 => 'Not found',
    default => 'Error',
}, "\n";

Tieni switch quando un case richiede più istruzioni, o quando il fallthrough è proprio lo scopo, come nell'esempio dei piani. Per associare un valore a un risultato, match è più breve e più sicuro.