PHP Elvis Operator (?:) vs Null Coalescing Operator (??)

By the end of this page, you will understand how PHP's short ternary operator ?: and null coalescing operator ?? decide whether to return the left or right value. You will learn the key difference between falsy checks and null-or-undefined checks, see where they behave the same, and know which one to choose in real PHP code.

The two operators look similar, but they solve different problems.

• ?: is the short ternary operator, often called the Elvis operator.
• ?? is the null coalescing operator.

Their difference comes from what they test.

?: checks for truthiness

$result = $a ?: $b;

This means:

$result = $a ? $a : $b;

So PHP evaluates $a as a boolean.

If $a is truthy, the result is $a. If $a is falsy, the result is $b.

In PHP, common falsy values include:

• false
• 0

Think of the two operators as two different gatekeepers.

?: is a strict "does this look usable?" gatekeeper

It looks at the value and says:

• "If this is truthy, keep it."
• "If this is falsy, replace it."

So values like 0 or "" get rejected, even if they are meaningful.

?? is a "is anything actually missing?" gatekeeper

It asks:

• "Is there a value here?"
• "Is it not null?"

If the answer is yes, it keeps the value, even if that value is 0, false, or "".

Simple analogy

Imagine filling out a form:

• ?: says: "This field looks empty or weak, so I will use the backup."
• ?? says: "I only use the backup if the field was not filled in at all, or was explicitly null."

That is the core difference: falsy vs missing/null.

Core syntax

$a ?: $b
$a ?? $b

Expanded forms

$a ?: $b   // same as: $a ? $a : $b
$a ?? $b   // similar to: isset($a) ? $a : $b

Example 1: value is 0

$a = 0;
$b = 100;

echo $a ?: $b;  // 100
echo "\n";
echo $a ?? $b;  // 0

Why?

• 0 is falsy, so ?: returns $b
• 0 is not null, so ?? returns

Consider this code:

$a = 0;
$b = 5;

$x = $a ?: $b;
$y = $a ?? $b;

Step-by-step for $x = $a ?: $b;

1. PHP reads $a.
2. PHP converts $a to a boolean for the condition.
3. $a is 0, which is falsy.
4. Because the condition is false, PHP returns $b.
5. $x becomes 5.

Step-by-step for $y = $a ?? $b;

1. PHP checks whether $a is set and not null.
2. $a exists.
3. $a is 0, not .

Use ?? for optional input and defaults

Request parameters

$page = $_GET['page'] ?? 1;
$search = $_GET['search'] ?? '';

This is useful because the key may not exist at all.

Configuration values

$host = $config['host'] ?? 'localhost';
$port = $config['port'] ?? 3306;

If the config key is missing or null, a default is used.

Nested data access

$username = $user['profile']['username'] ?? 'guest';

Use ?: when any falsy value should trigger a fallback

Display label fallback

In real PHP projects, developers often use these operators in predictable patterns.

Pattern: safe defaults from arrays and request data

$sort = $_GET['sort'] ?? 'created_at';
$limit = $_GET['limit'] ?? 20;

This avoids notices for missing keys and keeps valid falsy values if they exist.

Pattern: environment and configuration fallback

$env = $_ENV['APP_ENV'] ?? 'production';
$debug = $config['debug'] ?? false;

This is common in framework bootstrapping and config loading.

Pattern: normalize output after processing

$title = trim($title) ?: 'Untitled';

After transforming data, ?: is useful when an empty result should be replaced.

Pattern: guard clause with defaults

{
      ?? ;
}

Mistake 1: using ?: when 0 is a valid value

$quantity = 0;
echo $quantity ?: 10; // 10

If 0 is a meaningful value, this is wrong.

Better

echo $quantity ?? 10; // 0

Mistake 2: using ?: with false when false is a real setting

$enabled = false;
$result = $enabled ?: true; // true

This overwrites a valid false value.

Better

$result =  ?? ; 

$a ?: $b   // uses $b if $a is falsy
$a ?? $b   // uses $b if $a is undefined or null

Use ?: when

• you want to reject all falsy values
• empty strings should fall back
• 0 and false should also fall back

Use ?? when

• a variable or array key may be missing
• null should trigger the default
• 0, false, and "" are valid values

Falsy values in PHP

These make ?: choose the right side:

• false
• 0
• 0.0
• ""
• "0"

What is the difference between ?: and ?? in PHP?

?: checks whether the left value is truthy. ?? checks whether the left value exists and is not null.

Does ?? behave like isset()?

Yes. a ?? b is roughly equivalent to isset($a) ? $a : $b.

Does ?: treat 0 as empty?

Yes. Since 0 is falsy in PHP, ?: will use the fallback value.

When do ?: and ?? return the same result?

They return the same result when the left side is null.

Which operator should I use for $_GET or $_POST values?

Usually , because request keys may be missing and values like or may still be valid.

• Ternary operator — ?: is a shorthand form of the ternary operator.
• Boolean truthiness in PHP — understanding falsy values explains why ?: behaves the way it does.
• isset() — ?? is closely related to how isset() checks variables.
• Null in PHP — ?? specifically treats null as the condition for fallback.
• Array key access — ?? is commonly used with optional array keys.
• Default values — both operators are often used to provide fallback values.
• Type juggling in PHP — PHP's automatic boolean conversion affects ?:.
• Guard clauses — developers often combine defaults and early returns in input validation.