?? Operator is an empty merge operator introduced by PHP 7, which is used to concisely handle null value checks. 1. It first checks whether the variable or array key exists and is not null. If so, it returns the value, otherwise it returns the default value, such as $array['key'] ?? 'default'. 2. Compared with the method of isset() combined with the ternary operator, it is more concise and supports chain calls, such as $_SESSION'user'['theme'] ?? $_COOKIE['theme'] ?? 'light'. 3. It is often used to safely handle form input, configuration reads and object attribute access, but only judges null, and does not recognize '', 0 or false as "empty". 4. When using it, be careful to avoid warnings caused by accessing non-existent nested structures. You can use helper functions such as array_get to achieve safe traversal. 5. Despite limited functionality, it is a significant effect in improving code readability and security, and is a recommended practice in modern PHP development.

Null checks are a common part of any PHP application. Whether you're pulling data from a database, processing user input, or reading configuration values, you've probably written more than a few isset() or !empty() checks in your time. But there's a cleaner, more concise way to handle these scenarios — and it starts with two simple question marks: ?? .

What Is the Null Coalescing Operator ( ?? )?

The ?? operator, known as the null coalescing operator , was introduced in PHP 7. It provides a neat way to check whether a variable or array key exists and is not null — and if it isn't, fall back to a default value.

Here's how it works:

 $value = $array['key'] ?? 'default';

This line means:
"If $array['key'] exists and is not null, assign it to $value . Otherwise, use 'default' ."

It's functionally similar to:

 $value = issue($array['key']) ? $array['key'] : 'default';

But much cleaner and easier to read — especially when chaining multiple checks.

Why ?? Beats Ternary isset()

Before PHP 7, handling undefined array keys safely meant wrapping ternary expressions in isset() :

 $username = issue($_GET['user']) ? $_GET['user'] : 'guest';

Not only is this verbose, but nesting these checks quickly becomes messy:

 $theme = isset($_SESSION['user']['preferences']['theme']) 
    ? $_SESSION['user']['preferences']['theme'] 
    : 'light';

With ?? , you can simplify deeply nested fallbacks:

 $theme = $_SESSION['user']['preferences']['theme'] ?? 'light';

And even chain multiple fallbacks:

 $theme = $_SESSION['user']['preferences']['theme'] 
    ?? $_COOKIE['theme'] 
    ?? 'light';

Each operand is evaluated left to right, returning the first one that exists and is not null.

Common Use Cases for ?? in Real Applications

Using ?? effectively can make your code more robust and readable. Here are some practical examples:

• Handling form inputs safely:

   $email = $_POST['email'] ?? null;

• Fetching configuration with fallbacks:

   $apiUrl = config('services.api.url') ?? 'https://api.example.com';

• Working with optional object properties:

   $title = $post->title ?? 'No title provided';

?? Note: ?? only checks for null . It will return values like '' , 0 , or false . If you need to treat those as "empty" too, stick with empty() or combine checks as needed.

Avoiding Common Pitfalls

While ?? is powerful, it's important to understand what it doesn't do:

• It doesn't check if a value is logically empty — just if it's set and not null.
• It won't prevent warnings if you access an invalid array structure without proper nesting checks.

For example:

 // This may still cause a warning if $_SESSION['user'] doesn't exist
$theme = $_SESSION['user']['preferences']['theme'] ?? 'light';

To avoid this, ensure the full path exists or use nested ?? carefully. One workaround is to use functions or helpers that safely traverse arrays:

 function array_get($array, $path, $default = null) {
    foreach (explode('.', $path) as $key) {
        if (!is_array($array) || !isset($array[$key])) {
            return $default;
        }
        $array = $array[$key];
    }
    return $array;
}

$theme = array_get($_SESSION, 'user.preferences.theme', 'light');

But for simple cases, ?? still wins in clarity and speed.

Basically, ?? is a small syntax feature that brings big improvements in code readingability and safety when dealing with potentially null values. Once you start using it, you'll wonder how you lived without it.

The above is the detailed content of The Power of `??`: Simplifying Null Checks in Your PHP Applications. For more information, please follow other related articles on the PHP Chinese website!