PHP Null-Coalescing-Operator: ?? und ??=

?? liefert den Wert links davon, wenn er existiert und nicht null ist, sonst den Wert rechts davon: $name = $_GET['name'] ?? 'Guest';. Anders als beim direkten Lesen des Schlüssels gibt es nie eine Warnung, wenn die Variable oder der Array-Schlüssel fehlt.

<?php
$name = $_GET["name"] ?? "Guest";
$lang = $_GET["lang"] ?? "en";

echo "<p>Hello, " . htmlspecialchars($name) . " (language: " . htmlspecialchars($lang) . ")</p>";
echo '<p><a href="?name=Ada">?name=Ada</a> | <a href="?name=Linus&lang=fi">?name=Linus&amp;lang=fi</a> | <a href="?">no query</a></p>';

Beim ersten Durchlauf gibt es keinen Query-String, also werden beide Standardwerte verwendet. Klicke im Tab Page auf einen Link, und das Skript läuft erneut mit gefülltem $_GET. $_GET["name"] ohne ?? zu lesen, würde bei diesem ersten Durchlauf in einer normalen PHP-Umgebung Warning: Undefined array key "name" ausgeben. Mehr über Request-Daten steht auf der Seite zu $_GET und$_POST.

?? ist eine kurze isset()-Prüfung

$a ?? $b bedeutet genau isset($a) ? $a : $b. Es funktioniert mit Variablen, Array-Schlüsseln in beliebiger Tiefe und Objekteigenschaften und hält beim ersten fehlenden Teil an, ohne sich zu beschweren.

<?php
$config = [
    "db" => ["host" => "localhost", "port" => null],
];

// The long way
$host = isset($config["db"]["host"]) ? $config["db"]["host"] : "127.0.0.1";

// The same with ??
$host = $config["db"]["host"] ?? "127.0.0.1";
$port = $config["db"]["port"] ?? 3306;        // null, so default
$user = $config["db"]["user"] ?? "root";      // missing key
$cache = $config["cache"]["ttl"] ?? 60;       // missing parent key too
$debug = $undefinedVariable ?? false;         // missing variable

var_dump($host, $port, $user, $cache, $debug);

Die Prüfung ist dieselbe, die isset macht, also bekommt auch ein Schlüssel, der mit dem Wert null existiert, den Standardwert.

?? verketten, um mehrere Quellen zu probieren

?? ist rechtsassoziativ, und du kannst beliebig viele verketten. PHP liefert den ersten Operanden, der gesetzt und nicht null ist.

<?php
$fromQuery = null;
$fromCookie = null;
$fromProfile = "fr";

$lang = $fromQuery ?? $fromCookie ?? $fromProfile ?? "en";
echo $lang, "\n";

$settings = ["theme" => null];
$theme = $settings["theme"] ?? $settings["defaultTheme"] ?? "light";
echo $theme, "\n";

??= weist nur bei null zu

$a ??= $b speichert $b in $a nur, wenn $a nicht gesetzt oder null ist. Das ist der kürzeste Weg, Standardwerte einzutragen oder etwas einmal zu berechnen und danach wiederzuverwenden.

<?php
$options = ["color" => "red", "size" => null];

$options["color"] ??= "blue";   // already set, unchanged
$options["size"] ??= "M";       // null, so assigned
$options["qty"] ??= 1;          // missing, so assigned
print_r($options);

// Compute once, reuse afterwards
function slowSquare(int $n): int {
    echo "computing $n\n";
    return $n * $n;
}
$cache = [];
foreach ([4, 4, 7, 4] as $n) {
    $cache[$n] ??= slowSquare($n);
    echo "$n squared is {$cache[$n]}\n";
}

Die rechte Seite von ??= wird nur ausgewertet, wenn die Zuweisung stattfindet, und deshalb erscheint computing 4 nur einmal.

?? vs ?: (kurzer Ternär-Operator)

?? prüft auf null. ?: prüft auf Truthiness. Bei Werten wie 0, "" und "0" liefern sie unterschiedliche Antworten:

<?php
$inputs = ["qty" => "0", "note" => "", "coupon" => null];

foreach (["qty", "note", "coupon", "missing"] as $key) {
    $viaCoalesce = $inputs[$key] ?? "default";
    $viaElvis = ($inputs[$key] ?? null) ?: "default";
    printf("%-8s ?? => %-10s ?: => %s\n",
        $key, var_export($viaCoalesce, true), var_export($viaElvis, true));
}

Eine Menge von "0" ist eine echte Eingabe: ?? behält sie, ?: ersetzt sie. ?: allein würde vor dem fehlenden Schlüssel warnen, deshalb schreibt der Block ($inputs[$key] ?? null) ?: .... Die Seite zum ternären Operator behandelt ?: selbst.

Der Nullsafe-Operator ?->

?-> ist die Objektversion derselben Idee und kam mit PHP 8. Ist das Objekt links null, stoppt die ganze Kette und liefert null, statt einen Error wie Call to a member function getAddress() on null zu werfen. Setze ein ?? ans Ende für einen Standardwert.

<?php
class Address {
    public function __construct(public string $city) {}
}

class User {
    public function __construct(public ?Address $address = null) {}
    public function getAddress(): ?Address { return $this->address; }
}

function findUser(int $id): ?User {
    return match ($id) {
        1 => new User(new Address("Paris")),
        2 => new User(),
        default => null,
    };
}

foreach ([1, 2, 3] as $id) {
    $city = findUser($id)?->getAddress()?->city ?? "unknown";
    echo "user $id: $city\n";
}

Nutzer 2 existiert, hat aber keine Adresse, und Nutzer 3 existiert gar nicht. Beide landen ohne Fehler beim Standardwert ?? "unknown".

Typischer Fehler: ?? hat eine niedrige Rangfolge

?? bindet schwächer als . und die arithmetischen Operatoren. In "Count: " . $count ?? 0 baut PHP also zuerst den String "Count: " . $count, der nie null ist, und der Standardwert wird nie verwendet.

<?php
$count = null;

echo "Count: " . $count ?? 0, "\n";     // the ?? applies to the whole string
echo "Count: " . ($count ?? 0), "\n";   // what was meant

Setze den Ausdruck mit ?? in Klammern, sobald er Teil eines größeren Ausdrucks ist.