View source for Conditional (computer programming)

{{Short description |Control flow statement that branches according to a Boolean expression}}

[[File:If-Then-Else-diagram.svg|thumb|If-then-else flow diagram]]
[[File:IF-THEN-ELSE-END flowchart.svg|thumb|right|A nested ''if–then–else'' flow diagram]]

In [[computer programming]], a '''conditional''' [[Statement (computer science)|statement]] directs [[computer program | program]] [[control flow]] based on the value of a ''condition''; a [[Boolean expression]]. A conditional [[Expression (computer science)|expression]] evaluates to a value without the [[Side effect (computer science)|side-effect]] of changing control flow. 

Many programming languages (such as [[C (programming language)|C]]) have distinct conditional statements and expressions. In pure [[functional programming]], a conditional expression does not have side-effects, many functional programming languages with conditional expressions (such as Lisp) support side-effects.

==Conditional statement{{anchor |conditional-statement}}==

===If-then-else statement{{anchor |if-then-else-statement}}===
{{Redirect |if-then-else |the album |If Then Else |the TV episode |If-Then-Else}}
Although the syntax of an if-then-else statement varies by language, the general syntax is shown as [[pseudocode]] below. The part represented by the ''condition'' placeholder is an expression that evaluates to either true or false. If true, control passes to ''consequent'' and when complete to after {{code |end if}}. If false, control passes to ''alternative'' and when complete to after {{code |end if}}. As the else clause is optional, the <code>else ''alternative''</code> part can be omitted. Typically, both ''consequent'' and ''alternative'' can be either a single statement or a [[Block (programming)|block]] of statements.

<syntaxhighlight lang="lua">
if condition then
    consequent
else
    alternative
end if
</syntaxhighlight>

The following example, also in pseudocode, replaces placeholders with example logic.

<syntaxhighlight lang="lua">
if stock = 0 then
    message = 'order new stock'
else
    message = 'there is stock'
end if
</syntaxhighlight>

====History and development====
In early programming languages, especially dialects of [[BASIC]], an if–then-else statement could only contain [[goto]] statements but this tended to result in hard-to-read [[spaghetti code]]. As a result, [[structured programming]], which supports control flow via code blocks, gained in popularity, until it became the norm in most BASIC variants and all languages. Such mechanisms and principles were based on the [[ALGOL]] family of languages, including [[Pascal (programming language)|Pascal]] and [[Modula-2]]. While it is possible to use goto in a structured way, structured programming makes this easier. A structured if–then–else statement is one of the key elements of structured programming, and it is present in most popular languages such as [[C (programming language)|C]], [[Java (programming language)|Java]], [[JavaScript]] and [[Visual Basic]].

====Dangling else====
{{Main |Dangling else}}
The convention is that an {{code|else}} clause, like the {{code|then}} clause, responds to the nearest preceding {{code|if}} clause; however, the semantics in some early languages, such as [[ALGOL 60]], of [[Nesting (computing)|nested]] conditionals, were less than clear; that is to say, the syntax was inadequate to specify one-and-always-the-same predicate {{code|if}} clause. Thus, the parser might randomly pair the {{code|else}} with any one of the perhaps manifold {{code|if}} clauses in the intended nested hierarchy.

{{content grid|content=
<div>For example, take the statement:
<syntaxhighlight lang=lua>
if A then if B then S else S2
</syntaxhighlight></div>
<div>or the same statement but indented for clarity:
<syntaxhighlight lang=lua>
if A then
  if B then
      S
  else 
      S2
</syntaxhighlight></div>}}
<div>may be [[Parsing|parsed]] either as meaning:</div>
{{content grid|content=
<div>
<syntaxhighlight lang=lua>
if A then (if B then S) else S2 end
</syntaxhighlight></div>
<div>
<syntaxhighlight lang=lua>
if A then
    (if B then S)
else 
    S2
end</syntaxhighlight></div>}}
<div>or as meaning:</div>
{{content grid|content=
<div>
<syntaxhighlight lang=lua>
if A then (if B then S else S2)</syntaxhighlight></div>
<div>
<syntaxhighlight lang=lua>
if A then
    (if B then S else S2)
end
</syntaxhighlight></div>}}

This is known as the [[dangling else]] problem. It is resolved in various ways, depending on the language (in some, by means of explicit block-ending syntax (such as {{code| end if}} ) or a block enclosure, such as curly brackets ( <code>{</code>⋯<code>}</code> ).

====Chaining{{anchor|else-if}}====
Chaining conditionals is often provided in a language via an else-if construct. Only the statements following the first condition that is true are executed. Other statements are skipped. In placeholder pseudocode:

<syntaxhighlight lang="lua">
if condition1 then 
  block1
else if condition2 then 
  block2
else if condition3 then 
  block3
  ...
else
  block4
end if
</syntaxhighlight>

In the following pseudocode, a shop offers as much as a 30% discount for an item. If the discount is 10%, then the first if statement is true and "{{samp|you have to pay $30}}" is printed. All other statements below that first if statement are skipped.

<syntaxhighlight lang="lua">
if discount < 11% then 
  print "You have to pay $30."
else if discount < 21% then 
  print "You have to pay $20."
else if discount < 31% then 
  print "You have to pay $10."
end if
</syntaxhighlight>

Only one {{code|end if}} is needed if one uses {{code|else if}} instead of {{code|else}} followed by {{code|if}}.

In [[ALGOL 68]], the 1968 “Draft Report” (circulated as a supplement to [[ALGOL Bulletin]] no. 26) still used the '''bold''' keyword '''{{mono|elsf}}''' in “contracted” conditionals.<ref>{{cite report |title=Draft Report on the Algorithmic Language ALGOL 68 |publisher=Mathematisch Centrum (Supplement to Algol Bulletin 26) |date=1968 |page=55|url=https://algol68-lang.org/docs/algol68-draft-report.pdf}}</ref>
The spelling '''{{mono|elif}}''' was then standardized in the “Revised Report on the Algorithmic Language ALGOL 68” (1973), which lists both the '''{{mono|bold}}''' words {{nowrap|<code>'''if''' ~ '''then''' ~ '''elif''' ~ '''else''' ~ '''fi'''</code>}} and their “brief” symbols, where {{mono|elif}} corresponds to <code>|:</code> in the compact form {{nowrap begin}}<code>( ~ | ~ |: ~ | ~ | ~ )</code>.{{nowrap end}}<ref>{{cite journal |title=Revised Report on the Algorithmic Language ALGOL 68 |journal=Algol Bulletin (Supplement 47) / Numer. Math. |date=1973 |pages=118–121 |quote=symbol tables: “bold {{mono|'''else if'''}}” → “{{mono|'''elif'''}}”; “brief {{mono|else if}}” → “{{mono|&vert;:}}”) |url=https://softwarepreservation.computerhistory.org/ALGOL/report/Algol68_revised_report-AB-600dpi.pdf}}</ref>

In [[Ada (programming language)|Ada]], the {{mono|elseif}} keyword is [[syntactic sugar]] for the two words {{code|else if|lang=Ada}}. 
[[PHP]] also supports an {{code|elseif|lang=PHP}} keyword<ref name="php_elseif">''[http://php.net/manual/control-structures.elseif.php PHP elseif syntax]''</ref> both for its curly brackets or colon syntaxes. 
[[Perl]] and [[Ruby (programming language)|Ruby]] provide the keyword {{perl2|elsif}} to avoid the large number of braces that would be required by multiple {{perl2|if}} and {{perl2|else}} statements. 
[[Python (programming language)|Python]] uses the special keyword {{python|elif}} because structure is denoted by indentation rather than braces, so a repeated use of {{python|else}} and {{python|if}} would require increased indentation after every condition. 
[[Visual Basic]], supports {{code|ElseIf|lang=vbnet}}.<ref name="vb_elseif">[https://docs.microsoft.com/dotnet/visual-basic/language-reference/statements/if-then-else-statement Visual Basic {{mono|ElseIf}} syntax]</ref> 
Similarly, the earlier [[UNIX shell]]s (later gathered up to the POSIX shell syntax<ref name="posixshell">[http://pubs.opengroup.org/onlinepubs/009695399/utilities/xcu_chap02.html POSIX standard shell syntax]</ref>) use {{mono|elif}} too, but giving the choice of delimiting with spaces, line breaks, or both.

However, in many languages more directly descended from Algol, such as [[Simula (programming language)|Simula]], [[Pascal (programming language)|Pascal]], BCPL and [[C (programming language)|C]], this special syntax for the {{code|else if}} construct is not present, nor is it present in the many syntactical derivatives of C, such as [[Java (programming language)|Java]], [[ECMAScript]], and so on. This works because in these languages, any ''single'' statement (in this case <code>'''if''' cond...</code>) can follow a conditional without being enclosed in a block.{{clarify|what works?|date=September 2025}}

If all terms in the sequence of conditionals are testing the value of a single expression (e.g., {{nowrap|{{codes|'''if''' x {{=}} 0|'''else if''' x {{=}} 1|'''else if''' x {{=}} 2|delimiter=,&nbsp;}}}} ...), an alternative is the [[switch statement]]. In a language that does not have a switch statement, these can be encoded as a chained if-then-else.

===Switch statement{{anchor |switch-statement}}===
A [[switch statement]] supports multiway branching; often comparing the value of an expression with constant values and transferring control to the code of the first match. There is usually a provision for a default action if no match is found. An [[optimizing compiler]] may use a [[control table]] to implement the logic of a switch statement. In a dynamic language, the cases may not be limited to constant expressions, and might extend to [[pattern matching]], as in the [[shell script]] example on the right, where the '*)' implements the default case as a [[regular expression]] matching any string.

===Guarded conditional===
The [[Guarded Command Language]] (GCL) of [[Edsger W. Dijkstra|Edsger Dijkstra]] supports conditional execution as a list of commands consisting of a Boolean-valued [[Guard (computer science)|guard]] (corresponding to a ''condition'') and its corresponding statement. In GCL, exactly one of the statements whose guards is true is evaluated, but which one is arbitrary. In this code
 '''if''' G0 → S0
  □ G1 → S1
 ...
  □ Gn → Sn
 '''fi'''
the G<sub>''i''</sub>'s are the guards and the S<sub>''i''</sub>'s are the statements. If none of the guards is true, the program's behavior is undefined.

GCL is intended primarily for reasoning about programs, but similar notations have been implemented in [[Concurrent Pascal]] and [[Occam (programming language)|occam]].

=== Arithmetic if ===
The earliest conditional statement in Fortran, up to [[Fortran 77]], was the arithmetic if statement which jumped to one of three labels depending on whether a value (of type integer, real, or double precision) is <0, 0, or >0.<ref name="fortran77">{{cite web |url = http://www.fortran.com/fortran/F77_std/rjcnf0001-sh-11.html#sh-11.4 |title = American National Standard Programming Language FORTRAN |access-date = 2007-09-09 |date = 1978-04-03 |archive-url = https://web.archive.org/web/20071011055359/http://www.fortran.com/fortran/F77_std/rjcnf0001-sh-11.html#sh-11.4 |archive-date = 2007-10-11 |url-status = dead }}</ref>

In the following code, control passes to one of the labels based on the value of {{code |e}}.

<syntaxhighlight lang="fortran">
      IF (e) label1, label2, label3
</syntaxhighlight>

This is equivalent to the following sequence.

<syntaxhighlight lang="fortran">
      e_temp = e
      IF (e_temp .LT. 0) GOTO label1
      IF (e_temp .EQ. 0) GOTO label2
      IF (e_temp .GT. 0) GOTO label3
</syntaxhighlight>

As it acts like [[goto]], arithmetic if is unstructured; not [[structured programming]]. It was the only conditional statement in the original implementation of Fortran on the [[IBM 704]] computer. On that computer, the test-and-branch op-code had three addresses for those three states. Other computers would have "flag" registers such as positive, zero, negative, even, overflow, carry, associated with the last arithmetic operations and would use instructions such as 'Branch if accumulator negative' then 'Branch if accumulator zero' or similar. Note that the expression is evaluated ''once only'', and in cases such as integer arithmetic where overflow may occur, the overflow or carry flags would be considered also.

The Arithmetic IF statement was listed as obsolescent starting with the Fortran 90 Standard.  It was deleted from the Fortran 2018 Standard.  Nonetheless most compilers continue to support it for compatibility with legacy codes.

===In Smalltalk===

In contrast to other languages, in [[Smalltalk]] the conditional statement is not a [[language construct]] but defined in the class <code>Boolean</code> as an abstract method that takes two parameters, both [[Closure (computer science)|closure]]s. <code>Boolean</code> has two subclasses, <code>True</code> and <code>False</code>, which both define the method, <code>True</code> executing the first closure only, <code>False</code> executing the second closure only.<ref name="Smalltalk conditionals">{{cite web |url = http://wiki.cs.uiuc.edu/VisualWorks/Conditional+Processing |title = VisualWorks: Conditional Processing |date = 2006-12-16 |access-date = 2007-09-09 |archive-url = https://web.archive.org/web/20071022201949/http://wiki.cs.uiuc.edu/VisualWorks/Conditional+Processing |archive-date = 2007-10-22 |url-status = dead }}</ref>

<syntaxhighlight lang="smalltalk">
var = condition 
    ifTrue: [ 'foo' ]
    ifFalse: [ 'bar' ]
</syntaxhighlight>

===In JavaScript===
[[JavaScript]] supports if-else statements similar to [[C syntax]]. The following example has conditional {{jscode|Math.random() < 0.5}} which is true if the random float (value between 0 and 1) is greater than 0.5. The statement uses it to randomly choose between outputting {{samp|You got Heads!}} or {{samp|You got Tails!}}.

<syntaxhighlight lang="javascript">
if (Math.random() < 0.5) {
  console.log("You got Heads!");
} else {
  console.log("You got Tails!");
}
</syntaxhighlight>

Conditionals can be chained as shown below:

<syntaxhighlight lang="javascript">
var x = Math.random();
if (x < 1/3) {
  console.log("One person won!");
} else if (x < 2/3) {
  console.log("Two people won!");
} else {
  console.log("It's a three-way tie!");
}
</syntaxhighlight>

=== Lambda calculus ===
In [[Lambda calculus]], the concept of an if-then-else conditional can be expressed using the following expressions:
 true = λx. λy. x
 false = λx. λy. y
 ifThenElse = (λc. λx. λy. (c x y))
# {{mono|true}} takes up to two arguments and once both are provided (see [[currying]]), it returns the first argument given. 
# {{mono|false}} takes up to two arguments and once both are provided(see [[currying]]), it returns the second argument given.
# {{mono|ifThenElse}} takes up to three arguments and once all are provided, it passes both second and third argument to the first argument(which is a function that given two arguments, and produces a result). We expect {{mono|ifThenElse}} to only take true or false as an argument, both of which project the given two arguments to their preferred single argument, which is then returned. 
'''Note''': if {{mono|ifThenElse}} is passed two functions as the left and right conditionals; it is '''necessary''' to also pass an empty tuple {{code|()}} to the result of {{mono|ifThenElse}} in order to actually call the chosen function, otherwise {{mono|ifThenElse}} will just return the [[function object]] without getting called.

In a system where numbers can be used without definition (like Lisp, Traditional paper math, so on), the above can be expressed as a single closure below:
<syntaxhighlight lang="lisp">
((λtrue. λfalse. λifThenElse.
    (ifThenElse true 2 3)
)(λx. λy. x)(λx. λy. y)(λc. λl. λr. c l r))
</syntaxhighlight>
Here, {{mono|true, false,}} and {{mono|ifThenElse}} are bound to their respective definitions which are passed to their scope at the end of their block.

A working JavaScript analogy(using only functions of single variable for rigor) to this is as follows:
<syntaxhighlight lang="JavaScript">
var computationResult = ((_true => _false => _ifThenElse => 
    _ifThenElse(_true)(2)(3) 
)(x => y => x)(x => y => y)(c => x => y => c(x)(y)));
</syntaxhighlight>
The code above with multivariable functions looks like this:
<syntaxhighlight lang="JavaScript">
var computationResult = ((_true, _false, _ifThenElse) =>
    _ifThenElse(_true, 2, 3)
)((x, y) => x, (x, y) => y, (c, x, y) => c(x, y));
</syntaxhighlight>
Another version of the earlier example without a system where numbers are assumed is below.

The first example shows the first branch being taken, while second example shows the second branch being taken.
<syntaxhighlight lang="lisp">
((λtrue. λfalse. λifThenElse.
    (ifThenElse true (λFirstBranch. FirstBranch) (λSecondBranch. SecondBranch))
)(λx. λy. x)(λx. λy. y)(λc. λl. λr. c l r))

((λtrue. λfalse. λifThenElse.
    (ifThenElse false (λFirstBranch. FirstBranch) (λSecondBranch. SecondBranch))
)(λx. λy. x)(λx. λy. y)(λc. λl. λr. c l r))
</syntaxhighlight>
Smalltalk uses a similar idea for its true and false representations, with {{smalltalk|True}} and {{smalltalk|False}} being singleton objects that respond to messages {{mono|ifTrue/ifFalse}} differently.

Haskell used to use this exact model for its Boolean type, but at the time of writing, most Haskell programs use syntactic sugar {{haskell|if a then b else c}} construct which unlike {{mono|ifThenElse}} does not compose unless
either wrapped in another function or re-implemented as shown in The Haskell section of this page.

==Conditional expression{{anchor |conditional-expression}}==
{{See also |Ternary conditional operator}}
Many languages support a conditional expression, which unlike a statement evaluates to a value instead of controlling control flow. The concept of conditional expression was first developed by [[John McCarthy (computer scientist)|John McCarthy]] during his research into symbolic processing and LISP in the late 1950s.

===Examples===

====Algol====
[[ALGOL 60]] and some other members of the [[ALGOL]] family allow <code>if–then–else</code> as an expression.  The idea of including conditional expressions was suggested by John McCarthy, though the ALGOL committee decided to use English words rather than McCarthy's mathematical syntax:
<syntaxhighlight lang="pascal">
myvariable := if x > 20 then 1 else 2
</syntaxhighlight> <!-- Don't place a semicolon at the end of the above ALGOL statement. It is NOT C. -->


====[[ALGOL 68]]====

Compound statements are all terminated (guarded) by distinctive closing brackets:

*'''IF''' choice clauses:
  '''IF''' condition '''THEN''' statements [ '''ELSE''' statements ] '''FI'''
  "brief" form:  ( condition | statements | statements )

  '''IF''' condition1 '''THEN''' statements '''ELIF''' condition2 '''THEN''' statements [ '''ELSE''' statements ] '''FI'''
  "brief" form:  ( condition1 | statements |: condition2 | statements | statements )

This scheme not only avoids the [[dangling else]] problem but also avoids having to use <code>'''BEGIN'''</code> and <code>'''END'''</code> in embedded [[Statement (programming)|statement]] sequences.

*'''CASE''' choice clauses:
  '''CASE''' switch '''IN''' statements, statements,... [ '''OUT''' statements ] '''ESAC'''
  "brief" form:  ( switch | statements,statements,... | statements )

  '''CASE''' switch1 '''IN''' statements, statements,... '''OUSE''' switch2 '''IN''' statements, statements,... [ '''OUT''' statements ] '''ESAC'''
  "brief" form of '''CASE''' statement:  ( switch1 | statements,statements,... |: switch2 | statements,statements,... | statements )

Choice clause example with ''Brief'' symbols:

 '''PROC''' days in month = ('''INT''' year, month)'''INT''':
   (month|
     31,
     (year÷×4=0 ∧ year÷×100≠0  ∨  year÷×400=0 | 29 | 28 ),
     31, 30, 31, 30, 31, 31, 30, 31, 30, 31
   );

====Lisp====
Conditional expressions have always been a fundamental part of [[Lisp (programming language)|Lisp]]{{nbsp}}.  In pure LISP, the <code>COND</code> function is used.  In dialects such as [[Scheme (programming language)|Scheme]], [[Racket (programming language)|Racket]] and [[Common Lisp]]{{nbsp}}:
<syntaxhighlight lang="scheme">
;; Scheme
(define (myvariable x) (if (> x 12) 1 2))   ; Assigns 'myvariable' to 1 or 2, depending on the value of 'x'
</syntaxhighlight>

<syntaxhighlight lang="lisp">
;; Common Lisp
(let ((x 10))
  (setq myvariable (if (> x 12) 2 4)))  ; Assigns 'myvariable' to 2
</syntaxhighlight>

{{See also|McCarthy Formalism}}

====Haskell====
{{Main|Haskell (programming language)}}

In [[Haskell (programming language)|Haskell]] 98, there is only an ''if expression'', no ''if statement'', and the <code>else</code> part is compulsory, as every expression must have some value.<ref name="haskell98report">''[http://www.haskell.org/onlinereport/ Haskell 98 Language and Libraries: The Revised Report]''</ref> Logic that would be expressed with conditionals in other languages is usually expressed with [[pattern matching]] in recursive functions.

Because Haskell is [[lazy evaluation|lazy]], it is possible to write control structures, such as ''if'', as ordinary expressions; the lazy evaluation means that an ''if function'' can evaluate only the condition and proper branch (where a strict language would evaluate all three). It can be written like this:<ref name="haskell-ifthenelse-proposal">"[http://haskell.org/haskellwiki/If-then-else If-then-else Proposal on HaskellWiki]"</ref>
<syntaxhighlight lang="haskell">
if' :: Bool -> a -> a -> a
if' True x _ = x
if' False _ y = y
</syntaxhighlight>

====C-like languages====
[[C (programming language)|C]] and related languages support a [[ternary operator]] that provides for conditional expressions like:

 ''condition'' ? ''true-value'' : ''false-value''

If ''condition'' is true, then the expression evaluates to ''true-value''; otherwise to ''false-value''. In the following code, r is assigned to "foo" if x > 10; otherwise to "bar".

<syntaxhighlight lang="c">
r = x > 10 ? "foo" : "bar";
</syntaxhighlight>

To accomplish the same using an if-statement, this would take more than one statement, and require mentioning {{code| r}} twice:

<syntaxhighlight lang="c">
if (x > 10)
    r = "foo";
else
    r = "bar";
</syntaxhighlight>

Some argue that the explicit if-then statement is easier to read and that it may compile to more efficient code than the ternary operator,<ref>{{cite web|url=http://embeddedgurus.com/stack-overflow/2009/02/efficient-c-tips-6-dont-use-the-ternary-operator/ |title=Efficient C Tips #6 – Don't use the ternary operator « Stack Overflow |publisher=Embeddedgurus.com |date=2009-02-18 |access-date=2012-09-07}}</ref> while others argue that concise expressions are easier to read and better since they have less repeated clauses.

====Visual Basic====
{{Main|Visual Basic}}
In [[Visual Basic]] and some other languages, a function called <code>[[IIf]]</code> is provided, which can be used as a conditional expression. However, it does not behave like a true conditional expression, because both the true and false branches are always evaluated; it is just that the result of one of them is thrown away, while the result of the other is returned by the IIf function.

====Tcl====
{{Main|Tcl}}
In [[Tcl]] <code>if</code> is not a keyword but a function (in Tcl known as command or <code>proc</code>). For example
<syntaxhighlight lang="tcl">
if {$x > 10} {
    puts "Foo!"
}
</syntaxhighlight>
invokes a function named <code>if</code> passing 2 arguments: The first one being the condition and the second one being the true branch. Both arguments are passed as strings (in Tcl everything within curly brackets is a string).

In the above example the condition is not evaluated before calling the function. Instead, the implementation of the <code>if</code> function receives the condition as a string value and is responsible to evaluate this string as an expression in the callers scope.<ref>{{cite web|title=New Control Structures|url=https://wiki.tcl-lang.org/page/New+Control+Structures|publisher=[[Tcler's wiki]]|access-date=August 21, 2020}}</ref>

Such a behavior is possible by using <code>uplevel</code> and <code>expr</code> commands. Uplevel makes it possible to implement new control constructs as Tcl procedures (for example, uplevel could be used to implement the while construct as a Tcl procedure).<ref>{{cite web|title=uplevel manual page|url=https://www.tcl.tk/man/tcl8.6/TclCmd/uplevel.htm|publisher=[[www.tcl.tk]]|access-date=August 21, 2020}}</ref>

Because <code>if</code> is actually a function it also returns a value. The return value from the command is the result of the body script that was executed, or an [[empty string]] if none of the expressions was non-zero and there was no bodyN.<ref>{{cite web|title=if manual page|url=http://www.tcl.tk/man/tcl8.6/TclCmd/if.htm|publisher=[[www.tcl.tk]]|access-date=August 21, 2020}}</ref>

====Rust====
{{Main |Rust (programming language)}}

In [[Rust (programming language)|Rust]], <code>if</code> is always an expression. It evaluates to the value of whichever branch is executed, or to the unit type <code>()</code> if no branch is executed. If a branch does not provide a return value, it evaluates to <code>()</code> by default. To ensure the <code>if</code> expression's type is known at [[compile time]], each branch must evaluate to a value of the same type. For this reason, an <code>else</code> branch is effectively compulsory unless the other branches evaluate to <code>()</code>, because an <code>if</code> without an <code>else</code> can always evaluate to <code>()</code> by default.<ref>{{cite web|title=If and if let expressions|url=https://doc.rust-lang.org/reference/expressions/if-expr.html|access-date=November 1, 2020}}</ref>

The following assigns {{code |r}} to 1 or 2 depending on the value of x.

<syntaxhighlight lang="rust">
let r = if x > 20 {
    1
} else {
    2
};
</syntaxhighlight>

Values can be omitted when not needed.

<syntaxhighlight lang="rust">
if x > 20 {
    println!("x is greater than 20");
}
</syntaxhighlight>

==Pattern matching==
[[Pattern matching]] is an alternative to conditional statements (such as if–then–else and switch). It is available in many languages with functional programming features, such as [[Wolfram Language]], [[ML (programming language)|ML]] and many others. Here is a simple example written in the [[OCaml]] language:

<syntaxhighlight lang="ocaml">
match fruit with
| "apple" -> cook pie
| "coconut" -> cook dango_mochi
| "banana" -> mix;;
</syntaxhighlight>

The power of pattern matching is the ability to ''concisely'' match not only actions but also ''values'' to patterns of data. Here is an example written in [[Haskell (programming language)|Haskell]] which illustrates both of these features:

<syntaxhighlight lang="haskell">
map _ []      = []
map f (h : t) = f h : map f t
</syntaxhighlight>

This code defines a function ''map'', which applies the first argument (a function) to each of the elements of the second argument (a list), and returns the resulting list. The two lines are the two definitions of the function for the two kinds of arguments possible in this case – one where the list is empty (just return an empty list) and the other case where the list is not empty.

Pattern matching is not strictly speaking ''always'' a choice construct, because it is possible in Haskell to write only one alternative, which is guaranteed to always be matched – in this situation, it is not being used as a choice construct, but simply as a way to bind names to values. However, it is frequently used as a choice construct in the languages in which it is available.

== Hash-based conditionals ==
In programming languages that have [[associative array]]s or comparable data structures, such as [[Python (programming language)|Python]], [[Perl]], [[PHP]] or [[Objective-C]], it is idiomatic to use them to implement conditional assignment.<ref>{{cite web|url=http://codingstyleguide.com/style/180/python-pythonic-way-to-implement-switchcase-statements|title=Pythonic way to implement switch/case statements|access-date=2015-01-19|archive-url=https://web.archive.org/web/20150120120833/http://codingstyleguide.com/style/180/python-pythonic-way-to-implement-switchcase-statements|archive-date=2015-01-20|url-status=dead}}</ref>

<syntaxhighlight lang="python">
pet = input("Enter the type of pet you want to name: ")
known_pets = {
    "Dog": "Fido",
    "Cat": "Meowsles",
    "Bird": "Tweety",
}
my_name = known_pets[pet]
</syntaxhighlight>

In languages that have [[anonymous function]]s or that allow a programmer to assign a named function to a variable reference, conditional flow can be implemented by using a hash as a [[dispatch table]].

==Branch predication==
An alternative to conditional branch instructions is [[branch predication]]. Predication is an [[Instruction set architecture |architectural]] feature that enables instructions to be conditionally executed instead of modifying the [[control flow]].

== Choice system cross reference ==

This table refers to the most recent language specification of each language. For languages that do not have a specification, the latest officially released implementation is referred to.

{| class="wikitable"
|-
! rowspan=2 | [[Programming language]]
! colspan=3 | Structured if
! rowspan=2 | [[switch statement|switch]]–select–case
! rowspan=2 | Conditional expressions
! rowspan=2 | [[Arithmetic IF|Arithmetic if]]
! rowspan=2 | [[Pattern matching]]{{ref label|pattern matching|A|none}}
|-
! then
! else
! else–if
|-
|{{rh}}| [[Ada (programming language)|Ada]]
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{no}}
| {{no}}
|- 
|{{rh}}| [[ALGOL-60]]
| {{yes}}
| {{yes}}
| {{no2|Unneeded}}{{ref label|choice else if|C|2}}
| {{no}}
| {{yes}}
| {{no}}
| {{no}}
|-
|{{rh}}| [[ALGOL 68]]
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}} - '''case''' clause
| {{yes}} - Conformity clause
|-
|{{rh}}| [[APL (programming language)|APL]]
| {{no}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{no}}
| {{no}}
|-
|{{rh}}| [[Bash (Unix shell)|Bash shell]]
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{no}}
| {{yes}}
|- 
|{{rh}}| [[C (programming language)|C]], [[C++]]
| {{no}}
| {{yes}}
| {{no2|Unneeded}}{{ref label|preprocessor elif|B|1}}{{ref label|choice else if|C|6}}
| {{yes2|Fall-through}}
| {{yes}}
| {{no}}
| {{no}}
|- 
|{{rh}}| [[C Sharp (programming language)|C#]]
| {{no}}
| {{yes}}
| {{no2|Unneeded}}{{ref label|preprocessor elif|B|2}}{{ref label|choice else if|C|2}}
| {{yes}}
| {{yes}}
| {{no}}
| {{no}}
|- 
|{{rh}}| [[COBOL]]
| {{no2|Unneeded}}
| {{yes}}
| {{no2|Unneeded}}{{ref label|choice else if|C|2}}
| {{yes}}
| {{no}}
| {{no}}
| {{no}}
|- 
|{{rh}}| [[Eiffel (programming language)|Eiffel]]
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes|[[switch statement#Eiffel|Yes]]}} 
| {{yes}}
| {{no}}
| {{no}}
|- 
|{{rh}}| [[F Sharp (programming language)|F#]]
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}{{ref label|choice const|D|1}}
| {{yes}}
| {{no}}
| {{yes}}
|- 
|{{rh}}| [[Fortran]]
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}{{ref label|fortran|G|none}}
| {{yes}}{{ref label|fortran|I|none}}
| {{no}}
|- 
|{{rh}}| [[Go (programming language)|Go]]
| {{no}}
| {{yes}}
| {{no2|Unneeded}}{{ref label|choice else if|C|1}}
| {{yes}}
| {{no}}
| {{no}}
| {{no}}
|- 
|{{rh}}| [[Haskell (programming language)|Haskell]]
| {{yes}}
| {{yes2|Needed}}
| {{no2|Unneeded}}{{ref label|choice else if|C|3}}
| {{yes}}{{ref label|choice const|D|2}}
| {{yes}}
| {{no}}
| {{yes}}
|- 
|{{rh}}| [[Java (programming language)|Java]] 
| {{no}}
| {{yes}}
| {{no2|Unneeded}}{{ref label|choice else if|C|4}}
| {{yes2|Fall-through}}<ref name="JLS">[http://java.sun.com/docs/books/jls/download/langspec-3.0.pdf Java.sun.com], Java Language Specification, 3rd Edition.</ref>
| {{yes}}
| {{no}}
| {{no}}
|- 
|{{rh}}| [[ECMAScript]] ([[JavaScript]])
| {{no}}
| {{yes}}
| {{no2|Unneeded}}{{ref label|choice else if|C|5}}
| {{yes2|Fall-through}}<ref name="ECMA-262">[http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf Ecma-international.org] {{Webarchive|url=https://web.archive.org/web/20150412040502/http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf |date=2015-04-12 }} ECMAScript Language Specification, 5th Edition.</ref>
| {{yes}}
| {{no}}
| {{no}}
|-
|{{rh}}| [[Mathematica]]
| {{no}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{no}}
| {{yes}}
|-
|{{rh}}| [[Oberon (programming language)|Oberon]]
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{no}}
| {{no}}
| {{no}}
|- 
|{{rh}}| [[Perl]]
| {{no}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{no}}
| {{no}}
|- 
|{{rh}}| [[PHP]]
| {{no}}
| {{yes}}
| {{yes}}
| {{yes2|Fall-through}}
| {{yes}}
| {{no}}
| {{yes}}
|-
|{{rh}}| [[Pascal (programming language)|Pascal]], [[Object Pascal]] ([[Delphi (programming language)|Delphi]])
| {{yes}}
| {{yes}}
| {{no2|Unneeded}}
| {{yes}}
| {{no}}
| {{no}}
| {{no}}
|-
|{{rh}}| [[Python (programming language)|Python]]
| {{no}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{no}}
| {{yes}}
|-
|{{rh}}| [[QuickBASIC]]
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{no}}
| {{no}}
| {{no}}
|-
|{{rh}}| [[Ruby (programming language)|Ruby]]
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{no}}
| {{yes}}{{ref label|ruby|H|none}}
|-
|{{rh}}| [[Rust (programming language)|Rust]]
| {{no}}
| {{yes}}
| {{yes}}
| {{yes}}{{ref label|choice const|D|3}}
| {{yes}}
| {{no}}
| {{yes}}
|-
|{{rh}}| [[Scala (programming language)|Scala]]
| {{no}}
| {{yes}}
| {{no2|Unneeded}}{{ref label|choice else if|C|4}}
| {{yes2|Fall-through}}{{Citation needed|date=November 2015}}
| {{yes}}
| {{no}}
| {{yes}}
|-
|{{rh}}| [[SQL]]
| {{yes}}{{ref label|SQL|F|1}}
| {{yes}}
| {{yes}}
| {{yes}}{{ref label|SQL|F|2}}
| {{yes}}
| {{no}}
| {{no}}
|-
|{{rh}}| [[Swift (programming language)|Swift]]
| {{no}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{no}}
| {{yes}}
|-
|{{rh}}| [[Tcl]]
| {{no}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{no}}
| {{yes}}
|-
|{{rh}}| [[Visual Basic]], classic
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{no}}
| {{no}}
|-
|{{rh}}| [[Visual Basic .NET]]
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{no}}
| {{no}}
|- 
|{{rh}}| [[Windows PowerShell]] 
| {{no}}
| {{yes}}
| {{yes}}
| {{yes2|Fall-through}}
| {{yes}}
| {{no}}
| {{no}}
|}
{{ordered list|type=upper-alpha
|{{note label|pattern matching|A|none}} This refers to pattern matching as a distinct conditional construct in the programming language – as opposed to mere string pattern matching support, such as [[regular expression]] support.
|{{note label|preprocessor elif|B|1}}{{note label|preprocessor elif|B|2}} An #ELIF directive is used in the [[preprocessor]] sub-language that is used to modify the code before compilation; and to [[Include directive|include]] other files.
|{{note label|choice else if|C|1}} {{note label|choice else if|C|2}} {{note label|choice else if|C|3}} {{note label|choice else if|C|4}} {{note label|choice else if|C|5}} {{note label|choice else if|C|6}}The often-encountered <code>else if</code> in the C family of languages, and in COBOL and Haskell, is not a language feature but a set of nested and independent ''if then else'' statements combined with a particular source code layout. However, this also means that a distinct else–if construct is not really needed in these languages.
|{{note label|choice const|D|1}} {{note label|choice const|D|2}} {{note label|choice const|D|3}} Case-expressions in Haskell and match-expressions in F# and Haskell allow both switch-case and pattern matching usage.
|{{note label|case regexp|E|none}} In a Ruby <code>case</code> construct, [[regular expression]] matching is among the conditional flow-control alternatives available. For an example, see [https://stackoverflow.com/q/6803647 this] Stack Overflow question.
|{{note label|SQL|F|1}}{{note label|SQL|F|2}} SQL has two similar constructs that fulfill both roles, both introduced in [[SQL-92]]. A "searched <code>CASE</code>" expression {{code|2=sql|CASE WHEN cond1 THEN expr1 WHEN cond2 THEN expr2 [...] ELSE exprDflt END}} works like <code>if ... else if ... else</code>, whereas a "simple <code>CASE</code>" expression: {{code|2=sql|CASE expr WHEN val1 THEN expr1 [...] ELSE exprDflt END}} works like a switch statement. For details and examples see [[Case (SQL)]].
|{{note label|fortran|G|none}} Fortran 90 added the <code>MERGE</code> intrinsic.  Fortran 2023 added the C-like ternary operator.
|{{note label|ruby|H|none}} Pattern matching was added in Ruby 3.0.<ref>{{cite web |title=Pattern Matching |url=https://docs.ruby-lang.org/en/3.0.0/doc/syntax/pattern_matching_rdoc.html |website=Documentation for Ruby 3.0}}</ref> Some pattern matching constructs are still experimental.
|{{note label|fortran|I|none}} Arithmetic <code>if</code> was marked as obsolescent in Fortran 90.  It was deleted as of the Fortran 2018 Standard.
}}

== See also ==
{{Portal|Computer programming}}
* [[Branch (computer science)]]
* [[Conditional compilation]]
* [[Dynamic dispatch]] for another way to make execution choices
* [[McCarthy Formalism]] for history and historical references
* [[Named condition]]
* [[Relational operator]]
* [[Test (Unix)]]
* [[Yoda conditions]]
* [[Conditional move]]

== References ==
{{Reflist}}

== External links ==
{{Wiktionary|then|else}}
* {{Commons category-inline}}
* [http://everythingfla.com/courses/video/8/69/ IF NOT (ActionScript 3.0)] video

{{DEFAULTSORT:Conditional (programming)}}
[[Category:Conditional constructs| ]]
[[Category:Articles with example pseudocode]]
[[Category:Articles with example C code]]
[[Category:Articles with example Pascal code]]
[[Category:Articles with example Haskell code]]
[[Category:Articles with example Python (programming language) code]]
[[Category:Articles with example Tcl code]]