Expresión match en PHP: match vs switch y match(true)

match ($value) { ... } compara un valor con una lista de ramas usando el === estricto y devuelve el resultado de la primera rama que coincide. Varios valores pueden compartir una rama, default recoge el resto y, si nada coincide, PHP lanza 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;

Fíjate en el punto y coma tras la llave de cierre: match es una expresión, como 1 + 2, así que todo el bloque es una sola sentencia de asignación. Cada rama es values => result, separadas por comas, y se permite una coma final tras la última rama.

Varios valores en una rama

Enumera los valores separados por comas. La rama coincide si el sujeto es idéntico (===) a cualquiera de ellos.

<?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";
}

Devolver match directamente desde una función, como aquí, es la forma más común de usarlo.

match vs switch

La misma correspondencia escrita de las dos formas, con una entrada que muestra la mayor diferencia: la comparación. switch usa ==, así que la cadena "1" coincide con case 1. match usa ===, así que 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 cuando conviertes un valor en otro. Quédate con switch cuando una rama necesita varias sentencias o cuando el fallthrough es lo que buscas; la página de switch tiene los dos casos.

UnhandledMatchError: cuando ninguna rama coincide

Sin una rama default, un valor que no coincide con nada es un error, no un null silencioso. Es una ventaja: un código de estado nuevo o una errata fallan de forma visible en lugar de colarse.

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

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

PHP se detiene con PHP Fatal error: Uncaught UnhandledMatchError: Unhandled match case of type string. Una configuración de desarrollo (con zend.exception_ignore_args desactivado) nombra el valor: Unhandled match case 'XL'. Corrígelo añadiendo default => 'other', o capturando el error donde se espera un valor desconocido:

<?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) para rangos y condiciones

match compara el sujeto con cada rama, así que si el sujeto es true, cada rama puede ser una condición. Gana la primera condición que se evalúe exactamente a 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";
}

Dos detalles de ese bloque. throw es una expresión desde PHP 8, así que puede ser el resultado de una rama. Y como la comparación es estricta, cada condición debe devolver un booleano real: una rama como $name => ... nunca coincide con true aunque $name sea una cadena no vacía. Solo se evalúa la rama que coincide, así que el throw solo se ejecuta con una edad negativa.

match con enums

match y los enums encajan bien: dentro de un método del enum, match ($this) asigna un valor a cada caso. Consulta enums en PHP para los propios enums.

<?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";
}

Aquí no hay default a propósito. Si alguien añade un quinto caso más adelante, llamar a color() con él lanza un error en lugar de devolver un color equivocado.

Varias sentencias en una rama

Una rama contiene una sola expresión, así que 'save' => { ...; ... } no es PHP válido. Lleva el trabajo a una función y llámala desde la rama. Las funciones de las ramas que no coinciden nunca se llaman.

<?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 a 'json' o 'xml' y vuelve a ejecutarlo.