PHP match-Ausdruck: match vs switch, match(true)

match ($value) { ... } vergleicht einen Wert strikt mit === mit einer Liste von Zweigen und liefert das Ergebnis des ersten passenden Zweigs. Mehrere Werte können sich einen Zweig teilen, default fängt den Rest ab, und wenn nichts passt, wirft PHP einen 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;

Beachte das Semikolon nach der schließenden Klammer: match ist ein Ausdruck, wie 1 + 2, also ist das Ganze eine einzige Zuweisung. Jeder Zweig hat die Form values => result, getrennt durch Kommas, und nach dem letzten Zweig ist ein abschließendes Komma erlaubt.

Mehrere Werte in einem Zweig

Liste die Werte mit Kommas auf. Der Zweig passt, wenn das Subjekt mit einem von ihnen identisch (===) ist.

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

match direkt aus einer Funktion zurückzugeben, wie hier, ist die häufigste Art, es zu verwenden.

match vs switch

Dieselbe Zuordnung auf beide Arten geschrieben, mit einer Eingabe, die den größten Unterschied zeigt: den Vergleich. switch verwendet ==, also passt der String "1" zu case 1. match verwendet ===, also nicht.

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

Verwende match, wenn du einen Wert in einen anderen umwandelst. Behalte switch, wenn ein Zweig mehrere Anweisungen braucht oder wenn der Fallthrough der Zweck ist; die Seite zu switch zeigt beide Fälle.

UnhandledMatchError: wenn kein Zweig passt

Ohne default-Zweig ist ein Wert, der zu nichts passt, ein Fehler und kein stilles null. Das ist gewollt: Ein neuer Statuscode oder ein Tippfehler scheitert laut, statt durchzurutschen.

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

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

PHP stoppt mit PHP Fatal error: Uncaught UnhandledMatchError: Unhandled match case of type string. Eine Entwicklungsumgebung (mit ausgeschaltetem zend.exception_ignore_args) nennt stattdessen den Wert: Unhandled match case 'XL'. Behebe es entweder, indem du default => 'other' hinzufügst, oder indem du den Fehler dort abfängst, wo ein unbekannter Wert zu erwarten ist:

<?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) für Bereiche und Bedingungen

match vergleicht das Subjekt mit jedem Zweig, also kann jeder Zweig eine Bedingung sein, wenn das Subjekt true ist. Die erste Bedingung, die genau true ergibt, gewinnt.

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

Zwei Details in diesem Block. throw ist seit PHP 8 ein Ausdruck und kann deshalb das Ergebnis eines Zweigs sein. Und weil der Vergleich strikt ist, muss jede Bedingung einen echten Boolean liefern: Ein Zweig wie $name => ... passt nie zu true, selbst wenn $name ein nicht leerer String ist. Nur der passende Zweig wird ausgewertet, also läuft das throw nur bei einem negativen Alter.

match mit Enums

match und Enums passen zusammen: In einer Enum-Methode ordnet match ($this) jedem Case einen Wert zu. Zu Enums selbst siehe PHP-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";
}

Hier gibt es absichtlich kein default. Wenn später jemand einen fünften Case hinzufügt, wirft der Aufruf von color() dafür einen Fehler, statt eine falsche Farbe zu liefern.

Mehrere Anweisungen in einem Zweig

Ein Zweig enthält einen Ausdruck, also ist 'save' => { ...; ... } kein gültiges PHP. Verschieb die Arbeit in eine Funktion und ruf sie im Zweig auf. Die Funktionen der nicht passenden Zweige werden nie aufgerufen.

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

Ändere $format auf 'json' oder 'xml' und führe den Code erneut aus.