Modernes PHP: strikte Typen, Enums, match

Nimm das PHP von heute an: strikte Typen, Pfeilfunktionen, den Nullsafe-Operator, Enums und den match-Ausdruck.

9 Min. · 3 Fragen

Modernes PHP setzt auf Typisierung. declare(strict_types=1) als erste Anweisung der Datei deaktiviert implizite Umwandlungen: Die Zeichenkette '10' an einen float-Parameter zu übergeben wirft einen TypeError, statt stillschweigend umgewandelt zu werden. Typisiere Parameter und Rückgabewerte: Deine Fehler tauchen früh und an der richtigen Stelle auf, statt drei Dateien später.

<?php

declare(strict_types=1);

function applyDiscount(
    float $price,
    float $rate = 0.1
): float {
    return round($price * (1 - $rate), 2);
}

echo applyDiscount(49.99);
echo PHP_EOL;
echo applyDiscount(100.0, 0.25);

Pfeilfunktionen fn verdichten anonyme Funktionen aus einem einzigen Ausdruck. Ein großer Vorteil gegenüber klassischen Closures: Sie erfassen die Variablen des übergeordneten Gültigkeitsbereichs automatisch, ohne eine use-Klausel. Sie glänzen zusammen mit array_map() und array_filter().

<?php

declare(strict_types=1);

$prices = [12.5, 49.9, 8.0, 120.0];
$rate = 0.2;

$discounted = array_map(
    fn (float $p): float => round($p * (1 - $rate), 2),
    $prices
);

$affordable = array_filter(
    $discounted,
    fn (float $p): bool => $p < 50
);

print_r($affordable);

Der Nullsafe-Operator ?-> bricht einen Aufruf ab, sobald ein Glied der Kette null ist, statt einen fatalen Fehler auszulösen. Zusammen mit ?? ersetzt er Pyramiden aus if-Anweisungen durch eine einzige lesbare Zeile.

<?php

declare(strict_types=1);

class Address
{
    public function __construct(
        public readonly string $city
    ) {
    }
}

class User
{
    public function __construct(
        public readonly ?Address $address = null
    ) {
    }
}

$alice = new User(new Address('Lyon'));
$bob = new User();

echo $alice->address?->city ?? 'Unknown city';
echo PHP_EOL;
echo $bob->address?->city ?? 'Unknown city';

Enums geben abgeschlossenen Wertemengen (Status, Rollen) einen echten Typ: Es wird unmöglich, einen nicht existierenden Status zu erzeugen. Und match ist eine deutliche Verbesserung gegenüber switch: strenger Vergleich, ein als Wert zurückgegebenes Ergebnis und ein UnhandledMatchError, wenn kein Fall passt - ein Schutz vor Versehen.

<?php

declare(strict_types=1);

enum OrderStatus: string
{
    case Pending = 'pending';
    case Shipped = 'shipped';
    case Delivered = 'delivered';

    public function label(): string
    {
        return match ($this) {
            self::Pending => 'Pending',
            self::Shipped => 'Shipped',
            self::Delivered => 'Delivered',
        };
    }
}

$status = OrderStatus::from('shipped');
echo $status->label();

Wissenscheck

Stelle sicher, dass du die wichtigsten Punkte dieser Lektion behalten hast.

1. Was passiert mit declare(strict_types=1), wenn du die Zeichenkette '10' an einen als float typisierten Parameter übergibst?
   • PHP wandelt die Zeichenkette stillschweigend in 10.0 um
   • PHP gibt lediglich eine Warnung aus und läuft weiter
   • PHP wirft einen TypeError
2. Was unterscheidet eine Pfeilfunktion fn() von einer klassischen Closure function()?
   • Sie kann mehrere Anweisungen enthalten
   • Sie erfasst die Variablen des übergeordneten Gültigkeitsbereichs automatisch, ohne use-Klausel
   • Sie läuft schneller
   • Sie kann keine Typen deklarieren
3. Welchen Vorteil hat der match-Ausdruck gegenüber switch?
   • Er vergleicht streng (===), liefert einen Wert zurück und wirft einen Fehler, wenn kein Fall passt
   • Er akzeptiert lose Vergleiche (==) für mehr Flexibilität
   • Er erlaubt das Durchfallen von einem Fall zum nächsten