The PHP Ternary Operator: Shorthand Conditionals Done Right

If you've been writing PHP for any length of time, you've reached for an if/else block when a one-liner would have done the job. The ternary operator — and its shorthand variants — are exactly that. They're not exotic; they're bread-and-butter PHP that you should use confidently.

The Standard Ternary

The classic form:

$result = $condition ? $valueIfTrue : $valueIfFalse;

Concrete example:

$role = $user->isAdmin() ? 'admin' : 'member';

The expression evaluates $user->isAdmin(). If truthy, $role gets 'admin'; otherwise 'member'. Clean, readable, one line.

The Shorthand Ternary (Elvis Operator)

PHP 5.3 introduced the shorthand ternary, sometimes called the Elvis operator (?:), which drops the middle operand:

$result = $value ?: $fallback;

This is equivalent to:

$result = $value ? $value : $fallback;

The expression evaluates $value and returns it if truthy; otherwise returns $fallback.

Practical example:

$username = $request->get('username') ?: 'Guest';

If the request contains a non-empty username, you get it. If it's null, an empty string, or 0, you fall back to 'Guest'. That's the common use case: providing a default when a value might be absent or empty.

The Null Coalescing Operator (??)

PHP 7 added the null coalescing operator, which you should reach for most often in modern PHP:

$result = $value ?? $fallback;

The key difference from ?: is that ?? only checks for null or an undefined variable/key. It does not treat 0, false, or empty strings as falsy.

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

This is safe even if $_GET['page'] is not set — no undefined index notice. It also won't discard 0 if that's a legitimate value.

Compare directly:

$count = 0;

$a = $count ?: 10;  // Returns 10 — because 0 is falsy
$b = $count ?? 10;  // Returns 0  — because 0 is not null

I've seen bugs introduced by using ?: where ?? was correct, precisely because developers didn't consider whether zero or false were valid values in their domain.

Null Coalescing Assignment (??=)

PHP 7.4 added ??=, a compact assignment shorthand:

$config['timeout'] ??= 30;

Equivalent to:

if (!isset($config['timeout'])) {
    $config['timeout'] = 30;
}

Useful for setting array or object defaults without verbosity. I use this regularly when building configuration merges or hydrating request data with sensible defaults.

Nesting: Possible, but Be Careful

You can chain ternaries, but PHP's left-associativity historically made nested ternaries behave unexpectedly. Since PHP 8.0, nesting ternaries without explicit parentheses produces a deprecation error that becomes fatal in later versions. Use parentheses if you must nest:

$label = ($score > 80) ? 'Excellent' : (($score > 50) ? 'Average' : 'Poor');

If you're reaching for a second or third nesting level, a proper if/elseif/else or a match expression is almost certainly more readable. Don't sacrifice clarity for brevity — the next engineer reading this code is usually you in six months.

When to Use Which

On Readability

Ternaries earn their place when the condition and both outcomes fit on one line and the intent is obvious. The moment you're squinting to parse it, write it out properly. Code is read far more often than it is written.

The ?? operator is worth adopting as a default habit in any modern PHP codebase — it's explicit about intent, safe with undefined keys, and reads naturally.

Quick Reference

// Standard ternary
$val = $x > 0 ? 'positive' : 'non-positive';

// Elvis — falsy fallback
$name = $input ?: 'Anonymous';

// Null coalescing — null/unset fallback
$page = $_GET['page'] ?? 1;

// Null coalescing assignment
$options['retries'] ??= 3;

Pick the right tool for the specific check you're doing, keep it readable, and you'll write cleaner PHP for it.