PHP Null Coalescing Operator: ?? and ??=

?? returns the value on its left if it exists and is not null, otherwise the value on its right: $name = $_GET['name'] ?? 'Guest';. Unlike reading the key directly, it never warns when the variable or array key is missing.

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

On the first run there is no query string, so both defaults are used. Click a link in the Page tab and the script runs again with $_GET filled in. Reading $_GET["name"] without ?? on that first run would print Warning: Undefined array key "name" on a normal PHP setup. More about request data is on the $_GET and$_POST page.

?? is a short isset() check

$a ?? $b means exactly isset($a) ? $a : $b. It works on variables, array keys at any depth, and object properties, and it stops at the first missing piece without complaint.

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

The check is the same one isset does, so a key that exists with the value null also takes the default.

Chain ?? to try several sources

?? is right-associative and you can chain as many as you like. PHP returns the first operand that is set and not null.

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

??= assigns only when null

$a ??= $b stores $b in $a only when $a is unset or null. It is the shortest way to fill in defaults or to compute something once and reuse it.

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

The right side of ??= is only evaluated when the assignment happens, which is why computing 4 appears once.

?? vs ?: (short ternary)

?? tests for null. ?: tests for truthiness. With values like 0, "" and "0" they give different answers:

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

A quantity of "0" is real input: ?? keeps it, ?: replaces it. ?: on its own would warn about the missing key, which is why the block wraps it as ($inputs[$key] ?? null) ?: .... The ternary operator page covers ?: itself.

The nullsafe operator ?->

?-> is the object version of the same idea, added in PHP 8. If the object on the left is null, the whole chain stops and returns null instead of throwing an Error such as Call to a member function getAddress() on null. Put ?? at the end for a default.

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

User 2 exists but has no address, and user 3 does not exist at all. Both reach the ?? "unknown" default without an error.

Common mistake: ?? has low precedence

?? binds more loosely than . and the arithmetic operators. So in "Count: " . $count ?? 0, PHP first builds the string "Count: " . $count, which is never null, and the default is never used.

<?php
$count = null;

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

Wrap the ?? expression in parentheses whenever it sits inside a larger expression.