Espressione match in PHP: match vs switch, match(true)

match ($value) { ... } confronta un valore con un elenco di rami usando il === stretto e restituisce il risultato del primo ramo che corrisponde. Più valori possono condividere un ramo, default raccoglie il resto, e se nulla corrisponde PHP lancia un UnhandledMatchError.

<?php
$status = 404;

$message = match ($status) {
    200, 201, 204 => 'Success',
    301, 302 => 'Redirect',
    404 => 'Not found',
    500 => 'Server error',
    default => 'Unknown status',
};

echo $message;

Nota il punto e virgola dopo la graffa di chiusura: match è un'espressione, come 1 + 2, quindi il tutto è un'unica istruzione di assegnazione. Ogni ramo è valori => risultato, separato da virgole, ed è consentita una virgola finale dopo l'ultimo ramo.

Più valori in un ramo

Elenca i valori separati da virgole. Il ramo corrisponde se il soggetto è identico (===) a uno qualsiasi di essi.

<?php
function dayType(string $day): string
{
    return match ($day) {
        'sat', 'sun' => 'weekend',
        'mon', 'tue', 'wed', 'thu', 'fri' => 'weekday',
        default => 'not a day',
    };
}

foreach (['sat', 'wed', 'holiday'] as $d) {
    echo "$d: ", dayType($d), "\n";
}

Restituire match direttamente da una funzione, come qui, è il modo più comune di usarlo.

match vs switch

La stessa associazione scritta nei due modi, con un input che mostra la differenza più grande: il confronto. switch usa ==, quindi la stringa "1" corrisponde a case 1. match usa ===, quindi no.

<?php
$input = "1"; // a string, as it would come from a form

switch ($input) {
    case 1:
        $fromSwitch = 'one';
        break;
    default:
        $fromSwitch = 'other';
}

$fromMatch = match ($input) {
    1 => 'one',
    default => 'other',
};

echo "switch: $fromSwitch\n";
echo "match:  $fromMatch\n";
echo "match after (int): ", match ((int) $input) { 1 => 'one', default => 'other' }, "\n";

Usa match quando trasformi un valore in un altro. Tieni switch quando un ramo richiede più istruzioni o quando il fallthrough è lo scopo; la pagina su switch mostra entrambi i casi.

UnhandledMatchError: quando nessun ramo corrisponde

Senza un ramo default, un valore che non corrisponde a nulla è un errore, non un null silenzioso. È una funzionalità: un nuovo codice di stato o un errore di battitura fallisce in modo evidente invece di passare inosservato.

<?php
// This throws an UnhandledMatchError on purpose
$size = 'XL';

echo match ($size) {
    'S' => 'small',
    'M' => 'medium',
    'L' => 'large',
};

PHP si ferma con PHP Fatal error: Uncaught UnhandledMatchError: Unhandled match case of type string. Una configurazione di sviluppo (con zend.exception_ignore_args disattivato) indica invece il valore: Unhandled match case 'XL'. Risolvi aggiungendo default => 'other', oppure catturando l'errore dove un valore sconosciuto è previsto:

<?php
function sizeName(string $size): string
{
    return match ($size) {
        'S' => 'small',
        'M' => 'medium',
        'L' => 'large',
    };
}

foreach (['M', 'XL'] as $size) {
    try {
        echo sizeName($size), "\n";
    } catch (\UnhandledMatchError $e) {
        echo "Unknown size: $size\n";
    }
}

match(true) per intervalli e condizioni

match confronta il soggetto con ogni ramo, quindi se il soggetto è true, ogni ramo può essere una condizione. Vince la prima condizione che vale esattamente true.

<?php
function ageGroup(int $age): string
{
    return match (true) {
        $age < 0 => throw new InvalidArgumentException('Age cannot be negative'),
        $age < 13 => 'child',
        $age < 18 => 'teenager',
        $age < 65 => 'adult',
        default => 'senior',
    };
}

foreach ([8, 15, 40, 70] as $age) {
    echo "$age: ", ageGroup($age), "\n";
}

try {
    ageGroup(-1);
} catch (InvalidArgumentException $e) {
    echo "Error: ", $e->getMessage(), "\n";
}

Due dettagli in quel blocco. Da PHP 8 throw è un'espressione, quindi può essere il risultato di un ramo. E dato che il confronto è stretto, ogni condizione deve restituire un vero booleano: un ramo come $name => ... non corrisponde mai a true anche quando $name è una stringa non vuota. Viene valutato solo il ramo che corrisponde, quindi il throw viene eseguito solo per un'età negativa.

match con gli enum

match e gli enum vanno d'accordo: dentro un metodo di un enum, match ($this) associa ogni case a un valore. Vedi gli enum in PHP per gli enum stessi.

<?php
enum Suit
{
    case Hearts;
    case Diamonds;
    case Clubs;
    case Spades;

    public function color(): string
    {
        return match ($this) {
            Suit::Hearts, Suit::Diamonds => 'Red',
            Suit::Clubs, Suit::Spades => 'Black',
        };
    }
}

foreach (Suit::cases() as $suit) {
    echo $suit->name, " is ", $suit->color(), "\n";
}

Qui niente default, di proposito. Se in futuro qualcuno aggiunge un quinto case, chiamare color() su di esso lancia un errore invece di restituire un colore sbagliato.

Più istruzioni in un ramo

Un ramo contiene un'espressione, quindi 'save' => { ...; ... } non è PHP valido. Sposta il lavoro in una funzione e chiamala dal ramo. Le funzioni dei rami che non corrispondono non vengono mai chiamate.

<?php
function exportCsv(array $rows): string
{
    $lines = array_map(fn($r) => implode(',', $r), $rows);
    return implode("\n", $lines);
}

function exportJson(array $rows): string
{
    return json_encode($rows);
}

$rows = [['Ada', 36], ['Linus', 28]];
$format = 'csv';

echo match ($format) {
    'csv' => exportCsv($rows),
    'json' => exportJson($rows),
    default => "Unsupported format: $format",
};

Cambia $format in 'json' o 'xml' ed eseguilo di nuovo.