Ternary conditional operator
Conditional operator in computer programming
- 18 min read
- 3 chapters
Related on Lably
Through Computer programming, Conditional (computer programming) and Data type
Although a ternary operator in general is any operator with three arguments, the three-argument conditional operator is the only common one in programming, so it is loosely called the ternary operator.
C introduced the syntax a ? b : c, read as "if a then b otherwise c", which is widely used by other languages with C-like syntax. Some languages use functional syntax: in Visual Basic, it is written If(a, b, c).
Many languages support conditional expressions with two, three, or more clauses. Languages following ALGOL-like syntax often support them with the same syntax as conditional statements, if a then b else c.
The construct first appeared in CPL in 1963, as a → b, c.
Patterns
Assignment
The value of the operator can be assigned to a variable. For a weakly typed language, the data type of the selected value may determine the type of the assigned value. For a strongly typed language, both value expressions must evaluate to a type that is compatible with the target variable.
The operator is similar to the way conditional expressions (if-then-else) work in functional programming languages, like Scheme, ML, Haskell, and XQuery, since if-then-else forms an expression instead of a statement in those languages.
The operator allows for initializing a variable via a single statement which otherwise might require multiple statements. Use in variable assignment reduces the probability of a bug from a faulty assignment as the assigned variable is stated only once.
For example, in Python:
<span id="mwQg"></span><span class="n" id="mwQw">x</span><span class="p" id="mwRA">:</span> <span class="nb" id="mwRQ">str</span> <span class="o" id="mwRg">=</span> <span class="s1" id="mwRw">'foo'</span> <span class="k" id="mwSA">if</span> <span class="n" id="mwSQ">b</span> <span class="k" id="mwSg">else</span> <span class="s1" id="mwSw">'bar'</span>
instead of:
<span id="mwTw"></span><span class="n" id="mwUA">x</span><span class="p" id="mwUQ">:</span> <span class="nb" id="mwUg">str</span> <span class="k" id="mwUw">if</span> <span class="n" id="mwVA">b</span><span class="p" id="mwVQ">:</span> <span class="n" id="mwVg">x</span> <span class="o" id="mwVw">=</span> <span class="s1" id="mwWA">'foo'</span> <span class="k" id="mwWQ">else</span><span class="p" id="mwWg">:</span> <span class="n" id="mwWw">x</span> <span class="o" id="mwXA">=</span> <span class="s1" id="mwXQ">'bar'</span>
In a language with block scope, a variable must be declared before the if-else statement. For example:
<span id="mwYg"></span><span class="n" id="mwYw">std</span><span class="o" id="mwZA">::</span><span class="n" id="mwZQ">string</span><span class="w" id="mwZg"> </span><span class="n" id="mwZw">s</span><span class="p" id="mwaA">;</span> <span class="k" id="mwaQ">if</span><span class="w" id="mwag"> </span><span class="p" id="mwaw">(</span><span class="n" id="mwbA">b</span><span class="p" id="mwbQ">)</span><span class="w" id="mwbg"> </span><span class="p" id="mwbw">{</span> <span class="w" id="mwcA"> </span><span class="n" id="mwcQ">s</span><span class="w" id="mwcg"> </span><span class="o" id="mwcw">=</span><span class="w" id="mwdA"> </span><span class="s" id="mwdQ">"foo"</span><span class="p" id="mwdg">;</span> <span class="p" id="mwdw">}</span><span class="w" id="mweA"> </span><span class="k" id="mweQ">else</span><span class="w" id="mweg"> </span><span class="p" id="mwew">{</span> <span class="w" id="mwfA"> </span><span class="n" id="mwfQ">s</span><span class="w" id="mwfg"> </span><span class="o" id="mwfw">=</span><span class="w" id="mwgA"> </span><span class="s" id="mwgQ">"bar"</span><span class="p" id="mwgg">;</span> <span class="p" id="mwgw">}</span>Use of the conditional operator simplifies this:
<span id="mwhw"></span><span class="n" id="mwiA">std</span><span class="o" id="mwiQ">::</span><span class="n" id="mwig">string</span><span class="w" id="mwiw"> </span><span class="n" id="mwjA">s</span><span class="w" id="mwjQ"> </span><span class="o" id="mwjg">=</span><span class="w" id="mwjw"> </span><span class="n" id="mwkA">b</span><span class="w" id="mwkQ"> </span><span class="o" id="mwkg">?</span><span class="w" id="mwkw"> </span><span class="s" id="mwlA">"foo"</span><span class="w" id="mwlQ"> </span><span class="o" id="mwlg">:</span><span class="w" id="mwlw"> </span><span class="s" id="mwmA">"bar"</span><span class="p" id="mwmQ">;</span>
Furthermore, since initialization is now part of the declaration, rather than a separate statement, the identifier can be a constant. For example:
<span id="mwnQ"></span><span class="k" id="mwng">const</span><span class="w" id="mwnw"> </span><span class="n" id="mwoA">std</span><span class="o" id="mwoQ">::</span><span class="n" id="mwog">string</span><span class="w" id="mwow"> </span><span class="n" id="mwpA">s</span><span class="w" id="mwpQ"> </span><span class="o" id="mwpg">=</span><span class="w" id="mwpw"> </span><span class="n" id="mwqA">b</span><span class="w" id="mwqQ"> </span><span class="o" id="mwqg">?</span><span class="w" id="mwqw"> </span><span class="s" id="mwrA">"foo"</span><span class="w" id="mwrQ"> </span><span class="o" id="mwrg">:</span><span class="w" id="mwrw"> </span><span class="s" id="mwsA">"bar"</span><span class="p" id="mwsQ">;</span>
Case selector
The conditional operator can be used for case selectors. For example:
<span id="mwtg"></span><span class="n" id="mwtw">vehicle</span><span class="w" id="mwuA"> </span><span class="o" id="mwuQ">=</span><span class="w" id="mwug"> </span><span class="n" id="mwuw">arg</span><span class="w" id="mwvA"> </span><span class="o" id="mwvQ">==</span><span class="w" id="mwvg"> </span><span class="sc" id="mwvw">'B'</span><span class="w" id="mwwA"> </span><span class="o" id="mwwQ">?</span><span class="w" id="mwwg"> </span><span class="n" id="mwww">bus</span><span class="w" id="mwxA"> </span><span class="o" id="mwxQ">:</span> <span class="w" id="mwxg"> </span><span class="n" id="mwxw">arg</span><span class="w" id="mwyA"> </span><span class="o" id="mwyQ">==</span><span class="w" id="mwyg"> </span><span class="sc" id="mwyw">'A'</span><span class="w" id="mwzA"> </span><span class="o" id="mwzQ">?</span><span class="w" id="mwzg"> </span><span class="n" id="mwzw">airplane</span><span class="w" id="mw0A"> </span><span class="o" id="mw0Q">:</span> <span class="w" id="mw0g"> </span><span class="n" id="mw0w">arg</span><span class="w" id="mw1A"> </span><span class="o" id="mw1Q">==</span><span class="w" id="mw1g"> </span><span class="sc" id="mw1w">'T'</span><span class="w" id="mw2A"> </span><span class="o" id="mw2Q">?</span><span class="w" id="mw2g"> </span><span class="n" id="mw2w">train</span><span class="w" id="mw3A"> </span><span class="o" id="mw3Q">:</span> <span class="w" id="mw3g"> </span><span class="n" id="mw3w">arg</span><span class="w" id="mw4A"> </span><span class="o" id="mw4Q">==</span><span class="w" id="mw4g"> </span><span class="sc" id="mw4w">'C'</span><span class="w" id="mw5A"> </span><span class="o" id="mw5Q">?</span><span class="w" id="mw5g"> </span><span class="n" id="mw5w">car</span><span class="w" id="mw6A"> </span><span class="o" id="mw6Q">:</span> <span class="w" id="mw6g"> </span><span class="n" id="mw6w">arg</span><span class="w" id="mw7A"> </span><span class="o" id="mw7Q">==</span><span class="w" id="mw7g"> </span><span class="sc" id="mw7w">'H'</span><span class="w" id="mw8A"> </span><span class="o" id="mw8Q">?</span><span class="w" id="mw8g"> </span><span class="n" id="mw8w">horse</span><span class="w" id="mw9A"> </span><span class="o" id="mw9Q">:</span> <span class="w" id="mw9g"> </span><span class="n" id="mw9w">feet</span><span class="p" id="mw-A">;</span>
Sign in to keep reading
2 more chapters are free with a Lably account.
Variations
The syntax and semantics of the operator vary by language.
Major differences include whether the expressions can have side effects and whether the language provides short-circuit evaluation semantics, whereby only the selected expression is evaluated.
If a language supports expressions with side effects but does not specify short-circuit evaluation, then a further distinction exists about which expression evaluates first. If no order is guaranteed, a distinction exists about whether the result is then classified as indeterminate (the value obtained from some order) or undefined (any value at all at the whim of the compiler in the face of side effects, or even a crash).
If a language does not permit side-effects in expressions (common in functional languages), then the order of evaluation has no value semantics – though it may yet bear on whether an infinite recursion terminates, or have other performance implications (in a functional language with match expressions, short-circuit evaluation is inherent, and natural uses for the ternary operator arise less often, so this point is of limited concern).
For these reasons, in some languages the statement form r = condition ? expr1 : expr2 can have subtly different semantics than the block conditional form if (condition) { r = expr1; } else { r = expr2; }.
In almost all languages, the ternary operator is right associative, so that a == 1 ? "one" : a == 2 ? "two" : "many" evaluates intuitively as a == 1 ? "one" : (a == 2 ? "two" : "many"). This means it can be chained similarly to an if ... else if ... else if ... else chain. The main exception is PHP, in which it was left-associative (such that the same expression evaluates to (a == 1 ? "one" : a == 2) ? "two" : "many", which is rarely what the programmer expects) prior to version 8, and is non-associative thereafter.
Furthermore, in all C-family languages and many others, the ternary conditional operator has low operator precedence.
Examples
Ada
The 2012 edition of Ada introduced conditional expressions (using if and case), as part of an enlarged set of expressions including quantified expressions and expression functions. The Rationale for Ada 2012 states motives for Ada not having had them before, as well as motives for now adding them, such as to support "contracts" (also new).
<span id="mwAU8"></span><span class="n" id="mwAVA">Pay_per_Hour</span> <span class="p" id="mwAVE">:=</span> <span class="p" id="mwAVI">(</span><span class="kr" id="mwAVM">if</span> <span class="n" id="mwAVQ">Day</span> <span class="o" id="mwAVU">=</span> <span class="n" id="mwAVY">Sunday</span> <span class="kr" id="mwAVc">then</span> <span class="mf" id="mwAVg">12.50</span> <span class="kr" id="mwAVk">else</span> <span class="mf" id="mwAVo">10.00</span><span class="p" id="mwAVs">);</span>
When the value of an if_expression is itself of Boolean type, then the else part may be omitted, the value being True. Multiple conditions may chained using elsif.
ALGOL 60
ALGOL 60 introduced conditional expressions (ternary conditionals) to imperative programming languages.
This conditional statement:
<span id="mwAWc"></span><span class="kt" id="mwAWg">integer</span><span class="w" id="mwAWk"> </span><span class="n" id="mwAWo">opening_time</span><span class="o" id="mwAWs">;</span> <span class="k" id="mwAWw">if</span><span class="w" id="mwAW0"> </span><span class="n" id="mwAW4">day</span><span class="w" id="mwAW8"> </span><span class="o" id="mwAXA">=</span><span class="w" id="mwAXE"> </span><span class="n" id="mwAXI">Sunday</span><span class="w" id="mwAXM"> </span><span class="k" id="mwAXQ">then</span> <span class="w" id="mwAXU"> </span><span class="n" id="mwAXY">opening_time</span><span class="w" id="mwAXc"> </span><span class="o" id="mwAXg">:=</span><span class="w" id="mwAXk"> </span><span class="mi" id="mwAXo">12</span><span class="o" id="mwAXs">;</span> <span class="k" id="mwAXw">else</span> <span class="w" id="mwAX0"> </span><span class="n" id="mwAX4">opening_time</span><span class="w" id="mwAX8"> </span><span class="o" id="mwAYA">:=</span><span class="w" id="mwAYE"> </span><span class="mi" id="mwAYI">9</span><span class="o" id="mwAYM">;</span>
Can be rewritten with the conditional operator:
<span id="mwAYc"></span><span class="kt" id="mwAYg">integer</span><span class="w" id="mwAYk"> </span><span class="n" id="mwAYo">opening_time</span><span class="o" id="mwAYs">;</span> <span class="n" id="mwAYw">opening_time</span><span class="w" id="mwAY0"> </span><span class="o" id="mwAY4">:=</span><span class="w" id="mwAY8"> </span><span class="k" id="mwAZA">if</span><span class="w" id="mwAZE"> </span><span class="n" id="mwAZI">day</span><span class="w" id="mwAZM"> </span><span class="o" id="mwAZQ">=</span><span class="w" id="mwAZU"> </span><span class="n" id="mwAZY">Sunday</span><span class="w" id="mwAZc"> </span><span class="k" id="mwAZg">then</span><span class="w" id="mwAZk"> </span><span class="mi" id="mwAZo">12</span><span class="w" id="mwAZs"> </span><span class="k" id="mwAZw">else</span><span class="w" id="mwAZ0"> </span><span class="mi" id="mwAZ4">9</span><span class="o" id="mwAZ8">;</span>
ALGOL 68
Both ALGOL 68's choice clauses (if and case clauses) support the following:
- Single if choice clause
if condition then statements [ else statements ] fior a brief form:( condition | statements | statements )
- Chained if choice clause
if condition1 then statements elif condition2 then statements [ else statements ] fior a brief form:( condition1 | statements |: condition2 | statements | statements ).
Bash
A true ternary operator exists for arithmetic expressions:
<span id="mwAbI"></span><span class="o" id="mwAbM">((</span><span class="nv" id="mwAbQ">result</span><span class="w" id="mwAbU"> </span><span class="o" id="mwAbY">=</span><span class="w" id="mwAbc"> </span>condition<span class="w" id="mwAbg"> </span>?<span class="w" id="mwAbk"> </span>value_if_true<span class="w" id="mwAbo"> </span>:<span class="w" id="mwAbs"> </span>value_if_false<span class="o" id="mwAbw">))</span>
For strings there are workarounds, like e.g.:
<span id="mwAcA"></span><span class="nv" id="mwAcE">result</span><span class="o" id="mwAcI">=</span><span class="k" id="mwAcM">$(if</span><span class="w" id="mwAcQ"> </span>condition<span class="w" id="mwAcU"> </span><span class="p" id="mwAcY">;</span><span class="w" id="mwAcc"> </span><span class="k" id="mwAcg">then</span><span class="w" id="mwAck"> </span><span class="nb" id="mwAco">echo</span><span class="w" id="mwAcs"> </span><span class="s2" id="mwAcw">"value_if_true"</span><span class="w" id="mwAc0"> </span><span class="p" id="mwAc4">;</span><span class="w" id="mwAc8"> </span><span class="k" id="mwAdA">else</span><span class="w" id="mwAdE"> </span><span class="nb" id="mwAdI">echo</span><span class="w" id="mwAdM"> </span><span class="s2" id="mwAdQ">"value_if_false"</span><span class="w" id="mwAdU"> </span><span class="p" id="mwAdY">;</span><span class="w" id="mwAdc"> </span><span class="k" id="mwAdg">fi)</span>
Where condition can be any bash command. When it exits with success, the first echo command is executed, otherwise the second one is executed.
C family
The following code in C assigns result to the value of x if a > b, and otherwise to the value of y. This is the same syntax as in many related languages including C++, Java, JavaScript, and Dart.
<span id="mwAeg"></span><span class="n" id="mwAek">result</span><span class="w" id="mwAeo"> </span><span class="o" id="mwAes">=</span><span class="w" id="mwAew"> </span><span class="n" id="mwAe0">a</span><span class="w" id="mwAe4"> </span><span class="o" id="mwAe8">></span><span class="w" id="mwAfA"> </span><span class="n" id="mwAfE">b</span><span class="w" id="mwAfI"> </span><span class="o" id="mwAfM">?</span><span class="w" id="mwAfQ"> </span><span class="n" id="mwAfU">x</span><span class="w" id="mwAfY"> </span><span class="o" id="mwAfc">:</span><span class="w" id="mwAfg"> </span><span class="n" id="mwAfk">y</span><span class="p" id="mwAfo">;</span>
Only the selected expression is evaluated. In this example, x and y require no evaluation, but they can be expressions with side effects. Only the side-effect for the selected expression value will occur.
If x and y are of the same data type, the conditional expression generally has that type. Otherwise, the rules governing the resulting data type vary a little between languages:
- In C++, the usual arithmetic type conversions are performed to convert
xandyto a common type. If both are pointer or reference types, or one is a pointer type and the other is a constant expression evaluating to 0, pointer or reference conversions are performed to convert them to a common type. - In C#, if one expression is implicitly convertible to the type of the other, that type is used. Otherwise, a compile-time error occurs.
- In dynamically typed languages, the evaluated expression has the type of the selected expression.
Furthermore, in C++, a conditional expression can be used as an lvalue, if both x and y are lvalues, though this is rarely used in practice:
<span id="mwAiI"></span><span class="p" id="mwAiM">(</span><span class="n" id="mwAiQ">foo</span><span class="w" id="mwAiU"> </span><span class="o" id="mwAiY">?</span><span class="w" id="mwAic"> </span><span class="n" id="mwAig">bar</span><span class="w" id="mwAik"> </span><span class="o" id="mwAio">:</span><span class="w" id="mwAis"> </span><span class="n" id="mwAiw">baz</span><span class="p" id="mwAi0">)</span><span class="w" id="mwAi4"> </span><span class="o" id="mwAi8">=</span><span class="w" id="mwAjA"> </span><span class="n" id="mwAjE">frink</span><span class="p" id="mwAjI">;</span>
Common Lisp
Assignment using a conditional expression in Common Lisp:
<span id="mwAjg"></span><span class="p" id="mwAjk">(</span><span class="k" id="mwAjo">setq</span><span class="w" id="mwAjs"> </span><span class="nv" id="mwAjw">result</span><span class="w" id="mwAj0"> </span><span class="p" id="mwAj4">(</span><span class="k" id="mwAj8">if</span><span class="w" id="mwAkA"> </span><span class="p" id="mwAkE">(</span><span class="nb" id="mwAkI">></span><span class="w" id="mwAkM"> </span><span class="nv" id="mwAkQ">a</span><span class="w" id="mwAkU"> </span><span class="nv" id="mwAkY">b</span><span class="p" id="mwAkc">)</span><span class="w" id="mwAkg"> </span><span class="nv" id="mwAkk">x</span><span class="w" id="mwAko"> </span><span class="nv" id="mwAks">y</span><span class="p" id="mwAkw">))</span>
Alternative form:
<span id="mwAlA"></span><span class="p" id="mwAlE">(</span><span class="k" id="mwAlI">if</span><span class="w" id="mwAlM"> </span><span class="p" id="mwAlQ">(</span><span class="nb" id="mwAlU">></span><span class="w" id="mwAlY"> </span><span class="nv" id="mwAlc">a</span><span class="w" id="mwAlg"> </span><span class="nv" id="mwAlk">b</span><span class="p" id="mwAlo">)</span> <span class="w" id="mwAls"> </span><span class="p" id="mwAlw">(</span><span class="k" id="mwAl0">setq</span><span class="w" id="mwAl4"> </span><span class="nv" id="mwAl8">result</span><span class="w" id="mwAmA"> </span><span class="nv" id="mwAmE">x</span><span class="p" id="mwAmI">)</span> <span class="w" id="mwAmM"> </span><span class="p" id="mwAmQ">(</span><span class="k" id="mwAmU">setq</span><span class="w" id="mwAmY"> </span><span class="nv" id="mwAmc">result</span><span class="w" id="mwAmg"> </span><span class="nv" id="mwAmk">y</span><span class="p" id="mwAmo">))</span>
dBASE
In dBase, the conditional function iif(<expL>, <expT>, <expF>) is called "Immediate IF". It uses shortcut evaluation (it only evaluates one of <expT> or <expF>).
For example, to sort a list by the street name and then (in most cases) house number, one could type
<code class="tpl-codett mw-highlight mw-highlight-lang-vfp mw-content-ltr" style="border:none; padding: 0px 0px; color:var(--color-base, #202122); background:transparent;" dir="ltr" typeof="mw:Extension/syntaxhighlight mw:Transclusion" about="#mwt84" data-mw='{"name":"syntaxhighlight","attrs":{"lang":"vfp","class":"tpl-codett","style":"border:none; padding: 0px 0px; color:var(--color-base, #202122); background:transparent;","inline":"1"},"body":{"extsrc":"index on iif(instr(addr,\" \") , substr(addr,instr(addr,\" \")+1,10) + left(addr,instr(addr,\" \")-1) , addr)"},"parts":[{"template":{"target":{"wt":"codett","href":"./Template:Codett"},"params":{"1":{"wt":"index on iif(instr(addr,\" \") , substr(addr,instr(addr,\" \")+1,10) + left(addr,instr(addr,\" \")-1) , addr)"},"2":{"wt":"vfp"}},"i":0}}]}' id="mwAnU"><span class="kr" id="mwAnY">index</span> on <span class="nf" id="mwAnc">iif</span>(in<span class="nf" id="mwAng">str</span>(addr,<span class="s" id="mwAnk">" "</span>) , <span class="nf" id="mwAno">substr</span>(addr,in<span class="nf" id="mwAns">str</span>(addr,<span class="s" id="mwAnw">" "</span>)+1,10) + <span class="nf" id="mwAn0">left</span>(addr,in<span class="nf" id="mwAn4">str</span>(addr,<span class="s" id="mwAn8">" "</span>)-1) , addr)</code> to indexfileat the dBASE III command prompt, and then copy or export the table.
Fortran
As part of the Fortran-90 Standard, the ternary operator was added to Fortran as the intrinsic function merge:
<span id="mwAog"></span><span class="n" id="mwAok">variable</span><span class="w" id="mwAoo"> </span><span class="o" id="mwAos">=</span><span class="w" id="mwAow"> </span><span class="nb" id="mwAo0">merge</span><span class="p" id="mwAo4">(</span><span class="n" id="mwAo8">x</span><span class="p" id="mwApA">,</span><span class="n" id="mwApE">y</span><span class="p" id="mwApI">,</span><span class="n" id="mwApM">a</span><span class="o" id="mwApQ">></span><span class="n" id="mwApU">b</span><span class="p" id="mwApY">)</span>
Note that both x and y are evaluated before the results of one or the other are returned from the function. Here, x is returned if the condition holds true and y otherwise.
Fortran-2023 added conditional expressions which evaluate one or the other of the expressions based on the conditional expression:
<span id="mwAps"></span><span class="n" id="mwApw">variable</span><span class="w" id="mwAp0"> </span><span class="o" id="mwAp4">=</span><span class="w" id="mwAp8"> </span><span class="p" id="mwAqA">(</span><span class="w" id="mwAqE"> </span><span class="n" id="mwAqI">a</span><span class="w" id="mwAqM"> </span><span class="o" id="mwAqQ">></span><span class="w" id="mwAqU"> </span><span class="n" id="mwAqY">b</span><span class="w" id="mwAqc"> </span><span class="err" id="mwAqg">?</span><span class="w" id="mwAqk"> </span><span class="n" id="mwAqo">x</span><span class="w" id="mwAqs"> </span><span class="p" id="mwAqw">:</span><span class="w" id="mwAq0"> </span><span class="n" id="mwAq4">y</span><span class="w" id="mwAq8"> </span><span class="p" id="mwArA">)</span>
Kotlin
Kotlin does not include the traditional ?: ternary operator, however, an if can be used as an expression that can be assigned, achieving the same results.
<span id="mwArs"></span><span class="kd" id="mwArw">val</span><span class="w" id="mwAr0"> </span><span class="nv" id="mwAr4">max</span><span class="w" id="mwAr8"> </span><span class="o" id="mwAsA">=</span><span class="w" id="mwAsE"> </span><span class="k" id="mwAsI">if</span><span class="w" id="mwAsM"> </span><span class="p" id="mwAsQ">(</span><span class="n" id="mwAsU">a</span><span class="w" id="mwAsY"> </span><span class="o" id="mwAsc">></span><span class="w" id="mwAsg"> </span><span class="n" id="mwAsk">b</span><span class="p" id="mwAso">)</span><span class="w" id="mwAss"> </span><span class="n" id="mwAsw">a</span><span class="w" id="mwAs0"> </span><span class="k" id="mwAs4">else</span><span class="w" id="mwAs8"> </span><span class="n" id="mwAtA">b</span>
Lua
Lua does not have a traditional conditional operator. However, the short-circuiting behavior of its and and or operators allows the emulation of this behaviour. The following is equivalent to: var = cond ? a : b.
<span id="mwAto"></span><span class="nv" id="mwAts">var</span><span class="w" id="mwAtw"> </span><span class="o" id="mwAt0">=</span><span class="w" id="mwAt4"> </span><span class="nv" id="mwAt8">cond</span><span class="w" id="mwAuA"> </span><span class="ow" id="mwAuE">and</span><span class="w" id="mwAuI"> </span><span class="nv" id="mwAuM">a</span><span class="w" id="mwAuQ"> </span><span class="ow" id="mwAuU">or</span><span class="w" id="mwAuY"> </span><span class="nv" id="mwAuc">b</span>
This will succeed unless a is logically false; in this case, the expression will always result in b. This can result in some surprising behavior if ignored.
There are also other variants that can be used, but they're generally more verbose:
<span id="mwAu4"></span><span class="nv" id="mwAu8">var</span><span class="w" id="mwAvA"> </span><span class="o" id="mwAvE">=</span><span class="w" id="mwAvI"> </span><span class="p" id="mwAvM">(</span> <span class="w" id="mwAvQ"> </span><span class="p" id="mwAvU">{</span> <span class="w" id="mwAvY"> </span><span class="p" id="mwAvc">[</span><span class="kc" id="mwAvg">true</span><span class="p" id="mwAvk">]</span><span class="w" id="mwAvo"> </span><span class="o" id="mwAvs">=</span><span class="w" id="mwAvw"> </span><span class="nv" id="mwAv0">a</span><span class="p" id="mwAv4">,</span> <span class="w" id="mwAv8"> </span><span class="p" id="mwAwA">[</span><span class="kc" id="mwAwE">false</span><span class="p" id="mwAwI">]</span><span class="w" id="mwAwM"> </span><span class="o" id="mwAwQ">=</span><span class="w" id="mwAwU"> </span><span class="nv" id="mwAwY">b</span> <span class="w" id="mwAwc"> </span><span class="p" id="mwAwg">}</span> <span class="p" id="mwAwk">)[</span><span class="ow" id="mwAwo">not</span><span class="w" id="mwAws"> </span><span class="ow" id="mwAww">not</span><span class="w" id="mwAw0"> </span><span class="nv" id="mwAw4">cond</span><span class="p" id="mwAw8">]</span>Luau, a dialect of Lua, has ternary expressions that look like if statements, but unlike them, they have no end keyword, and the else clause is required. One may optionally add elseif clauses. It's designed to replace the cond and a or b idiom and is expected to work properly in all cases.
<span id="mwAyc"></span><span class="c1" id="mwAyg">-- in Luau</span> <span class="nv" id="mwAyk">var</span><span class="w" id="mwAyo"> </span><span class="o" id="mwAys">=</span><span class="w" id="mwAyw"> </span><span class="kr" id="mwAy0">if</span><span class="w" id="mwAy4"> </span><span class="nv" id="mwAy8">cond</span><span class="w" id="mwAzA"> </span><span class="o o-Reserved" id="mwAzE">then</span><span class="w" id="mwAzI"> </span><span class="nv" id="mwAzM">a</span><span class="w" id="mwAzQ"> </span><span class="kr" id="mwAzU">else</span><span class="w" id="mwAzY"> </span><span class="nv" id="mwAzc">b</span> <span class="c1" id="mwAzg">-- with elseif clause</span> <span class="nv" id="mwAzk">sign</span><span class="w" id="mwAzo"> </span><span class="o" id="mwAzs">=</span><span class="w" id="mwAzw"> </span><span class="kr" id="mwAz0">if</span><span class="w" id="mwAz4"> </span><span class="nv" id="mwAz8">var</span><span class="w" id="mwA0A"> </span><span class="o" id="mwA0E"><</span><span class="w" id="mwA0I"> </span><span class="mf" id="mwA0M">0</span><span class="w" id="mwA0Q"> </span><span class="kr" id="mwA0U">then</span><span class="w" id="mwA0Y"> </span><span class="o" id="mwA0c">-</span><span class="mf" id="mwA0g">1</span><span class="w" id="mwA0k"> </span><span class="kr" id="mwA0o">elseif</span><span class="w" id="mwA0s"> </span><span class="nv" id="mwA0w">var</span><span class="w" id="mwA00"> </span><span class="o" id="mwA04">==</span><span class="w" id="mwA08"> </span><span class="mf" id="mwA1A">0</span><span class="w" id="mwA1E"> </span><span class="kr" id="mwA1I">then</span><span class="w" id="mwA1M"> </span><span class="mf" id="mwA1Q">0</span><span class="w" id="mwA1U"> </span><span class="kr" id="mwA1Y">else</span><span class="w" id="mwA1c"> </span><span class="mf" id="mwA1g">1</span>
Object Pascal extensions
Pascal was both a simplification and extension of ALGOL 60, but it removed conditional expressions.
RemObjects Oxygene added a ternary operator to Object Pascal in approximately 2011, and in 2025 Delphi followed suit. Oxygene supports case/switch statements, essentially a repeated if, as expressions evaluating to a value as well.
Python
Python has had a ternary conditional expression since release 2.5 (September 2006). Python's conditional operator differs from the C-style ?: operator in the order of its operands. The general form is:
<span id="mwA3k"></span><span class="n" id="mwA3o">result</span> <span class="o" id="mwA3s">=</span> <span class="n" id="mwA3w">x</span> <span class="k" id="mwA30">if</span> <span class="n" id="mwA34">a</span> <span class="o" id="mwA38">></span> <span class="n" id="mwA4A">b</span> <span class="k" id="mwA4E">else</span> <span class="n" id="mwA4I">y</span>
This form invites considering x as the normal value and y as an exceptional case. Unlike Python conditional statements, the elif clause is not supported, but nested conditional expressions are allowed.
Ruby
Ruby has supported the ?: conditional operator since its first public release (version 0.95, December 1995), inheriting the syntax from Perl and C. Because Ruby is a purely expression-based language - every construct, including if/else, returns a value - the ternary operator is not strictly necessary, but it is idiomatic and preferred by the Ruby Style Guide for concise single-line conditional assignments.
<span id="mwA5E"></span><span class="w" id="mwA5I"> </span> <span class="n" id="mwA5M">status</span><span class="w" id="mwA5Q"> </span><span class="o" id="mwA5U">=</span><span class="w" id="mwA5Y"> </span><span class="n" id="mwA5c">age</span><span class="w" id="mwA5g"> </span><span class="o" id="mwA5k">>=</span><span class="w" id="mwA5o"> </span><span class="mi" id="mwA5s">18</span><span class="w" id="mwA5w"> </span><span class="o" id="mwA50">?</span><span class="w" id="mwA54"> </span><span class="s2" id="mwA58">"adult"</span><span class="w" id="mwA6A"> </span><span class="p" id="mwA6E">:</span><span class="w" id="mwA6I"> </span><span class="s2" id="mwA6M">"minor"</span>
Ruby's ? token is also used as a suffix on predicate method names (e.g. logged_in?), which can produce a visually ambiguous double question mark when such a method is used as the condition:
<span id="mwA6k"></span><span class="w" id="mwA6o"> </span> <span class="n" id="mwA6s">greeting</span><span class="w" id="mwA6w"> </span><span class="o" id="mwA60">=</span><span class="w" id="mwA64"> </span><span class="n" id="mwA68">logged_in?</span><span class="w" id="mwA7A"> </span><span class="p" id="mwA7E">?</span><span class="w" id="mwA7I"> </span><span class="s2" id="mwA7M">"Welcome back!"</span><span class="w" id="mwA7Q"> </span><span class="p" id="mwA7U">:</span><span class="w" id="mwA7Y"> </span><span class="s2" id="mwA7c">"Please sign in."</span>
The community style guide recommends using spaces around both ? and :, keeping each branch to a single expression. Nested ternary operators should be avoided — preferring if/elsif/else in those cases. Multi-line ternary expressions are also discouraged; a multi-line if/else block is preferred instead.
Rust
As an expression-oriented programming language, all Rust conditionals are expressions, not statements, so the if expr1 else expr2 syntax behaves like the C-style ?: ternary operator. Earlier versions of the language had a ?: operator but it was removed due to duplication with if.
Note the lack of semi-colons in the code below compared to an imperative if...else block, and the semi-colon at the end of the assignment to y.
<span id="mwA9o"></span><span class="kd" id="mwA9s">let</span><span class="w" id="mwA9w"> </span><span class="n" id="mwA90">x</span><span class="w" id="mwA94"> </span><span class="o" id="mwA98">=</span><span class="w" id="mwA-A"> </span><span class="mi" id="mwA-E">5</span><span class="p" id="mwA-I">;</span> <span class="kd" id="mwA-M">let</span><span class="w" id="mwA-Q"> </span><span class="n" id="mwA-U">y</span><span class="w" id="mwA-Y"> </span><span class="o" id="mwA-c">=</span><span class="w" id="mwA-g"> </span><span class="k" id="mwA-k">if</span><span class="w" id="mwA-o"> </span><span class="n" id="mwA-s">x</span><span class="w" id="mwA-w"> </span><span class="o" id="mwA-0">==</span><span class="w" id="mwA-4"> </span><span class="mi" id="mwA-8">5</span><span class="w" id="mwA_A"> </span><span class="p" id="mwA_E">{</span> <span class="w" id="mwA_I"> </span><span class="mi" id="mwA_M">10</span> <span class="p" id="mwA_Q">}</span><span class="w" id="mwA_U"> </span><span class="k" id="mwA_Y">else</span><span class="w" id="mwA_c"> </span><span class="p" id="mwA_g">{</span> <span class="w" id="mwA_k"> </span><span class="mi" id="mwA_o">15</span> <span class="p" id="mwA_s">};</span>This could also be written as:
<span id="mwA_8"></span><span class="kd" id="mwBAA">let</span><span class="w" id="mwBAE"> </span><span class="n" id="mwBAI">y</span><span class="w" id="mwBAM"> </span><span class="o" id="mwBAQ">=</span><span class="w" id="mwBAU"> </span><span class="k" id="mwBAY">if</span><span class="w" id="mwBAc"> </span><span class="n" id="mwBAg">x</span><span class="w" id="mwBAk"> </span><span class="o" id="mwBAo">==</span><span class="w" id="mwBAs"> </span><span class="mi" id="mwBAw">5</span><span class="w" id="mwBA0"> </span><span class="p" id="mwBA4">{</span><span class="w" id="mwBA8"> </span><span class="mi" id="mwBBA">10</span><span class="w" id="mwBBE"> </span><span class="p" id="mwBBI">}</span><span class="w" id="mwBBM"> </span><span class="k" id="mwBBQ">else</span><span class="w" id="mwBBU"> </span><span class="p" id="mwBBY">{</span><span class="w" id="mwBBc"> </span><span class="mi" id="mwBBg">15</span><span class="w" id="mwBBk"> </span><span class="p" id="mwBBo">};</span>Curly braces are mandatory in Rust conditional expressions.
You could also use a match expression:
<span id="mwBCA"></span><span class="kd" id="mwBCE">let</span><span class="w" id="mwBCI"> </span><span class="n" id="mwBCM">y</span><span class="w" id="mwBCQ"> </span><span class="o" id="mwBCU">=</span><span class="w" id="mwBCY"> </span><span class="k" id="mwBCc">match</span><span class="w" id="mwBCg"> </span><span class="n" id="mwBCk">x</span><span class="w" id="mwBCo"> </span><span class="p" id="mwBCs">{</span> <span class="w" id="mwBCw"> </span><span class="mi" id="mwBC0">5</span><span class="w" id="mwBC4"> </span><span class="o" id="mwBC8">=></span><span class="w" id="mwBDA"> </span><span class="mi" id="mwBDE">10</span><span class="p" id="mwBDI">,</span> <span class="w" id="mwBDM"> </span><span class="n" id="mwBDQ">_</span><span class="w" id="mwBDU"> </span><span class="o" id="mwBDY">=></span><span class="w" id="mwBDc"> </span><span class="mi" id="mwBDg">15</span><span class="p" id="mwBDk">,</span> <span class="p" id="mwBDo">};</span>Smalltalk
Every expression (message send) has a value. Thus ifTrue:ifFalse: can be used:
<span id="mwBEA"></span><span class="nv" id="mwBEE">|x</span><span class="w" id="mwBEI"> </span><span class="nv" id="mwBEM">y|</span> <span class="nv" id="mwBEQ">x</span><span class="w" id="mwBEU"> </span><span class="nv" id="mwBEY">:=</span><span class="w" id="mwBEc"> </span><span class="mf" id="mwBEg">5.</span> <span class="nv" id="mwBEk">y</span><span class="w" id="mwBEo"> </span><span class="nv" id="mwBEs">:=</span><span class="w" id="mwBEw"> </span><span class="p" id="mwBE0">(</span><span class="nf" id="mwBE4">x</span><span class="w" id="mwBE8"> </span><span class="nv" id="mwBFA">==</span><span class="w" id="mwBFE"> </span><span class="mi" id="mwBFI">5</span><span class="p" id="mwBFM">)</span><span class="w" id="mwBFQ"> </span><span class="nv" id="mwBFU">ifTrue:</span><span class="p" id="mwBFY">[</span><span class="mi" id="mwBFc">10</span><span class="p" id="mwBFg">]</span><span class="w" id="mwBFk"> </span><span class="nv" id="mwBFo">ifFalse:</span><span class="p" id="mwBFs">[</span><span class="mi" id="mwBFw">15</span><span class="p" id="mwBF0">]</span><span class="o" id="mwBF4">.</span>
SQL
The SQL CASE expression is a generalization of the ternary operator. Instead of one conditional and two results, n conditionals and n+1 results can be specified.
With one conditional it is equivalent (although more verbose) to the ternary operator:
<span id="mwBGc"></span><span class="k" id="mwBGg">SELECT</span><span class="w" id="mwBGk"> </span><span class="p" id="mwBGo">(</span><span class="k" id="mwBGs">CASE</span><span class="w" id="mwBGw"> </span><span class="k" id="mwBG0">WHEN</span><span class="w" id="mwBG4"> </span><span class="n" id="mwBG8">a</span><span class="w" id="mwBHA"> </span><span class="o" id="mwBHE">></span><span class="w" id="mwBHI"> </span><span class="n" id="mwBHM">b</span><span class="w" id="mwBHQ"> </span><span class="k" id="mwBHU">THEN</span><span class="w" id="mwBHY"> </span><span class="n" id="mwBHc">x</span><span class="w" id="mwBHg"> </span><span class="k" id="mwBHk">ELSE</span><span class="w" id="mwBHo"> </span><span class="n" id="mwBHs">y</span><span class="w" id="mwBHw"> </span><span class="k" id="mwBH0">END</span><span class="p" id="mwBH4">)</span><span class="w" id="mwBH8"> </span><span class="k" id="mwBIA">AS</span><span class="w" id="mwBIE"> </span><span class="n" id="mwBII">CONDITIONAL_EXAMPLE</span> <span class="w" id="mwBIM"> </span><span class="k" id="mwBIQ">FROM</span><span class="w" id="mwBIU"> </span><span class="n" id="mwBIY">tab</span><span class="p" id="mwBIc">;</span>
This can be expanded to several conditionals:
<span id="mwBIs"></span><span class="k" id="mwBIw">SELECT</span><span class="w" id="mwBI0"> </span><span class="p" id="mwBI4">(</span><span class="k" id="mwBI8">CASE</span><span class="w" id="mwBJA"> </span><span class="k" id="mwBJE">WHEN</span><span class="w" id="mwBJI"> </span><span class="n" id="mwBJM">a</span><span class="w" id="mwBJQ"> </span><span class="o" id="mwBJU">></span><span class="w" id="mwBJY"> </span><span class="n" id="mwBJc">b</span><span class="w" id="mwBJg"> </span><span class="k" id="mwBJk">THEN</span><span class="w" id="mwBJo"> </span><span class="n" id="mwBJs">x</span><span class="w" id="mwBJw"> </span><span class="k" id="mwBJ0">WHEN</span><span class="w" id="mwBJ4"> </span><span class="n" id="mwBJ8">a</span><span class="w" id="mwBKA"> </span><span class="o" id="mwBKE"><</span><span class="w" id="mwBKI"> </span><span class="n" id="mwBKM">b</span><span class="w" id="mwBKQ"> </span><span class="k" id="mwBKU">THEN</span><span class="w" id="mwBKY"> </span><span class="n" id="mwBKc">y</span><span class="w" id="mwBKg"> </span><span class="k" id="mwBKk">ELSE</span><span class="w" id="mwBKo"> </span><span class="n" id="mwBKs">z</span><span class="w" id="mwBKw"> </span><span class="k" id="mwBK0">END</span><span class="p" id="mwBK4">)</span><span class="w" id="mwBK8"> </span><span class="k" id="mwBLA">AS</span><span class="w" id="mwBLE"> </span><span class="n" id="mwBLI">CONDITIONAL_EXAMPLE</span> <span class="w" id="mwBLM"> </span><span class="k" id="mwBLQ">FROM</span><span class="w" id="mwBLU"> </span><span class="n" id="mwBLY">tab</span><span class="p" id="mwBLc">;</span>
Visual Basic
Visual Basic provides a ternary conditional function, IIf, as shown in the following code:
<span id="mwBL4"></span><span class="k" id="mwBL8">Dim</span><span class="w" id="mwBMA"> </span><span class="n" id="mwBME">opening_time</span><span class="w" id="mwBMI"> </span><span class="ow" id="mwBMM">As</span><span class="w" id="mwBMQ"> </span><span class="kt" id="mwBMU">Integer</span><span class="w" id="mwBMY"> </span><span class="o" id="mwBMc">=</span><span class="w" id="mwBMg"> </span><span class="n" id="mwBMk">IIf</span><span class="p" id="mwBMo">((</span><span class="n" id="mwBMs">day</span><span class="w" id="mwBMw"> </span><span class="o" id="mwBM0">=</span><span class="w" id="mwBM4"> </span><span class="n" id="mwBM8">SUNDAY</span><span class="p" id="mwBNA">),</span><span class="w" id="mwBNE"> </span><span class="mi" id="mwBNI">12</span><span class="p" id="mwBNM">,</span><span class="w" id="mwBNQ"> </span><span class="mi" id="mwBNU">9</span><span class="p" id="mwBNY">)</span>
As a function, the values of the three arguments are evaluated before the function is called. To avoid evaluating the expression that is not selected, the If keyword was added (in Visual Basic .Net 9.0) as a true ternary conditional operator. This allows the following code to avoid an exception if it were implemented with IIf instead:
<span id="mwBNw"></span><span class="k" id="mwBN0">Dim</span><span class="w" id="mwBN4"> </span><span class="n" id="mwBN8">name</span><span class="w" id="mwBOA"> </span><span class="ow" id="mwBOE">As</span><span class="w" id="mwBOI"> </span><span class="kt" id="mwBOM">String</span><span class="w" id="mwBOQ"> </span><span class="o" id="mwBOU">=</span><span class="w" id="mwBOY"> </span><span class="k" id="mwBOc">If</span><span class="p" id="mwBOg">(</span><span class="n" id="mwBOk">person</span><span class="w" id="mwBOo"> </span><span class="ow" id="mwBOs">Is</span><span class="w" id="mwBOw"> </span><span class="k" id="mwBO0">Nothing</span><span class="p" id="mwBO4">,</span><span class="w" id="mwBO8"> </span><span class="s" id="mwBPA">""</span><span class="p" id="mwBPE">,</span><span class="w" id="mwBPI"> </span><span class="n" id="mwBPM">person</span><span class="p" id="mwBPQ">.</span><span class="n" id="mwBPU">Name</span><span class="p" id="mwBPY">)</span>