When using the ?? operator, the default value is only used when the variable is null or undefined, which is suitable for processing existence checks such as array keys and user input; 2. When using the ?: operator, judge based on the true or falseness of the value (truthy/falsy), which is suitable for Boolean logic, state switching and conditional rendering; 3. The two can be used in combination, such as ($value ?? false) ?: 'default', check the existence first and then determine the authenticity; 4. Selecting the correct operator can improve the readability of the code and semantic clarity, ?? means "missing value processing", ?: means "logical judgment".

When dealing with conditional assignments in PHP, two operators often come up in conversation: the ternary operator ( ?: ) and the null coalescing operator ( ?? ) . At first glance, they might seem interchangeable — both provide a shorthand way to make decisions in your code. But they serve subtly different purposes, and using the right one can make your code clearer, safer, and more predictable.

Let's break down when and why to use each.

What Each Operator Actually Does

Ternary Operator ( ?: )

The ternary operator evaluates a truthy/falsy condition and returns one of two values based on that.

 $result = condition ? value_if_true : value_if_false;

It checks whether the condition (left side) is truthy. This includes values like 0 , '' (empty string), '0' , [] , false — all of which are "falsy" in PHP.

Example:

 $username = $input ? $input : 'guest';

If $input is '' , '0' , or 0 , this still counts as falsy — so 'guest' will be used, even if the value technically exists.

Null Coalescing Operator ( ?? )

The null coalescing operator checks specifically for null , nothing more. It returns the left operand if it exists and is not null ; otherwise, it returns the right operand.

 $result = value ?? default_value;

It doesn't care about truthiness — only whether the variable is absent or explicitly null .

Example:

 $username = $input ?? 'guest';

Even if $input is '' , 0 , or false , it's not null , so it will be used. Only if $input is undefined or null does 'guest' kick in.

Key Difference: Falsy vs Null

This is the core distinction:

? So if you want to distinguish between "value exists but is empty" and "value doesn't exist" , ?? is safe.

Practical Use Cases

Use ?? When: Defaulting Real Input

You're pulling from $_GET , user input, or array values that might not be set.

 $page = $_GET['page'] ?? 1;
$color = $settings['theme_color'] ?? 'blue';

Here, even if 'page' is 0 or 'theme_color' is an empty string, you likely still want to use that value — you only want a fallback if the key is missing or null .

Using ?: here could accidentally override valid data:

 // Risky: treats empty string as reason to fallback
$page = $_GET['page'] ?: 1; // fails if ?page=0 or ?page=

Use ?: When: You Care About Truthiness

You need to make a decision based on whether something is logically true.

 $status = $user->isActive() ? 'active' : 'inactive';
$message = $hasError ? 'Error!' : 'All good';

These aren't about presence — they're about meaning. The ternary is perfect here.

Also useful for inline formatting:

 echo "User is " . ($verified ? 'verified' : 'unverified');

Chaining and Nested Behavior

Both support chaining, but ?? was designed with deep fallbacks in mind.

 // Clean and safe
$username = $input['user'] ?? $input['author'] ?? 'unknown';

// Ternary equivalent gets messy fast
$username = !empty($input['user']) ? $input['user'] : 
            (!empty($input['author']) ? $input['author'] : 'unknown');

Note: Be careful with ternary chaining — it can become hard to read and has left-associative gotchas.

Also, you can combine both when needed:

 // Only fallback if not just empty/zero
$username = ($profile['name'] ?? false) ?: 'Anonymous';

This uses ?? to check existence, then ?: to check truthiness — useful if you want to treat '' or 0 as invalid.

Performance & Readability

• Performance : Both are extremely fast. Difference is negligible.
• Readability : ?? clearly signals “I'm handling missing values.” ?: says “I'm making a boolean decision.”

Choosing the right one acts as documentation. Other developers (and future you) will instantly understand intent.

Summary: When to Use Which?

• ? Use ?? when checking for existence/definedness — especially with arrays, user input, optional properties.
• ? Use ?: when evaluating logical truth — conditions, flags, computered booleans.
• ? Don't use ?: to check if a variable is set — use isset() or ?? instead.
• ? You can combine them when you need both exist and truthiness checks.

Basically, if you're defaulting configuration, request params, or array keys — go with ?? . If you're rendering conditional text or toggling state — ?: is fine.

It's not about which is better overall — it's about using the right tool for the semantic job .

The above is the detailed content of The Nuanced Showdown: PHP Ternary (`?:`) vs. Null Coalescing (`??`). For more information, please follow other related articles on the PHP Chinese website!