> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # PHP Ternary The `? :` operator, formally known as the ternary operator, is a conditional operator that evaluates a boolean expression and returns one of two subsequent expressions based on the truth value of the initial condition. It is the only operator in PHP that requires three operands. ```php theme={"dark"} $result = $condition ? $expression_if_true : $expression_if_false; ``` ## Mechanics and Evaluation 1. **Implicit Casting:** The first operand (`$condition`) is evaluated first. PHP implicitly casts this value to a boolean following standard type juggling rules. 2. **Short-Circuit Evaluation:** The operator exhibits short-circuiting behavior. * If the condition resolves to `true`, only the second operand (`$expression_if_true`) is evaluated and returned. * If the condition resolves to `false`, only the third operand (`$expression_if_false`) is evaluated and returned. * The unselected expression is entirely ignored, preventing potential side effects or execution errors within that branch. ## Shorthand Syntax (Elvis Operator) PHP supports a shorthand version of the ternary operator where the middle operand is omitted, represented as `?:`. ```php theme={"dark"} $result = $expression1 ?: $expression2; ``` In this form, `$expression1` is evaluated. If it resolves to a truthy value, the actual value of `$expression1` is returned. If it resolves to a falsy value, `$expression2` is evaluated and returned. Crucially, the Elvis operator evaluates `$expression1` only **once**. This is a major functional difference from the standard ternary equivalent (`$expression1 ? $expression1 : $expression2`), which evaluates the first expression twice if it is truthy. The single evaluation prevents unintended side effects and performance hits when the first expression involves a function call or a complex operation. ## Associativity and Chaining The associativity rules for the ternary operator underwent a significant change in recent PHP versions, which dictates how chained expressions are parsed. * **PHP 8.0 and later:** The ternary operator is strictly **non-associative**. Chaining multiple ternary operators without explicit grouping results in a `Fatal error: Unparenthesized a ? b : c ? d : e is not supported`. * **Prior to PHP 8.0:** The operator was **left-associative**. Expressions were evaluated from left to right, which contrasted with the right-associativity found in most other C-family languages and often led to unexpected evaluation trees. To chain ternary operators in modern PHP, explicit parentheses are mandatory to define the evaluation order: ```php theme={"dark"} // Valid syntax in PHP 8.0+ $result = $condition1 ? $expression1 : ($condition2 ? $expression2 : $expression3); ``` ## Operator Precedence The `? :` operator has lower precedence than most arithmetic, comparison, and logical operators, but higher precedence than assignment operators (`=`, `+=`, etc.) and the `yield` keyword. Because the ternary operator has lower precedence than comparison or mathematical operators, the condition naturally evaluates first without needing parentheses. However, a critical standard practice in PHP is wrapping the *entire ternary expression* in parentheses when combining it with other operations. For example, the string concatenation operator (`.`) has higher precedence than the ternary operator. Failing to wrap the ternary expression will cause the concatenation operator to incorrectly absorb the condition before the ternary logic is applied: ```php theme={"dark"} // Correct grouping required due to operator precedence $output = "Result: " . ($condition ? $expression_if_true : $expression_if_false); ```
Tired of Poor PHP Skills? Fix That With Deep Grasping! Learn More