# Conditional (computer programming)

(Redirected from If-then-else)
If-Then-Else flow diagram
A nested "If–Then–Else" flow diagram

In computer science, conditional statements, conditional expressions and conditional constructs are features of a programming language, which perform different computations or actions depending on whether a programmer-specified boolean condition evaluates to true or false. Apart from the case of branch predication, this is always achieved by selectively altering the control flow based on some condition.

In imperative programming languages, the term "conditional statement" is usually used, whereas in functional programming, the terms "conditional expression" or "conditional construct" are preferred, because these terms all have distinct meanings.

A conditional is sometimes colloquially referred to as an "if-check," especially when perceived as a simple one and when its specific form is irrelevant or unknown.

Although dynamic dispatch is not usually classified as a conditional construct, it is another way to select between alternatives at runtime.

## If–then(–else)

The `if–then` construct (sometimes called `if–then–else`) is common across many programming languages. Although the syntax varies from language to language, the basic structure (in pseudocode form) looks like this:

```If (boolean condition) Then
(consequent)
Else
(alternative)
End If
```

In the example code above, the part represented by (boolean condition) constitutes a conditional expression, having intrinsic value (e.g., it may be substituted by either of the values `True` or `False`) but having no intrinsic meaning. In contrast, the combination of this expression, the `If` and `Then` surrounding it, and the consequent that follows afterward constitute a conditional statement, having intrinsic meaning (e.g., expressing a coherent logical rule) but no intrinsic value.

When an interpreter finds an `If`, it expects a boolean condition – for example, `x > 0`, which means "the variable x contains a number that is greater than zero" – and evaluates that condition. If the condition is `true`, the statements following the `then` are executed. Otherwise, the execution continues in the following branch – either in the `else` block (which is usually optional), or if there is no `else` branch, then after the `end If`.

After either branch has been executed, control returns to the point after the `end If`.

In early programming languages, especially some dialects of BASIC in the 1980s home computers, an `if–then` statement could only contain `GOTO` statements. This led to a hard-to-read style of programming known as spaghetti programming, with programs in this style called spaghetti code. As a result, structured programming, which allows (virtually) arbitrary statements to be put in statement blocks inside an `if` statement, gained in popularity, until it became the norm even in most BASIC programming circles. Such mechanisms and principles were based on the older but more advanced ALGOL family of languages, and ALGOL-like languages such as Pascal and Modula-2 influenced modern BASIC variants for many years. While it is possible while using only `GOTO` statements in `if–then` statements to write programs that are not spaghetti code and are just as well structured and readable as programs written in a structured programming language, structured programming makes this easier and enforces it. Structured `if–then–else` statements like the example above are one of the key elements of structured programming, and they are present in most popular high-level programming languages such as C, Java, JavaScript and Visual Basic .

A subtlety is that the optional else clause found in many languages means that the context-free grammar is ambiguous, since nested conditionals can be parsed in multiple ways. Specifically,

```if a then if b then s else s2
```

can be parsed as

```if a then (if b then s) else s2
```

or

```if a then (if b then s else s2)
```

depending on whether the `else` is associated with the first `if` or second `if`. This is known as the dangling else problem, and is resolved in various ways, depending on the language.

### Else if

By using `else if`, it is possible to combine several conditions. Only the statements following the first condition that is found to be true will be executed. All other statements will be skipped.

```if condition then
--statements
elseif condition then
-- more statements
elseif condition then
-- more statements;
...
else
-- other statements;
end if;
```

The statements of `elseif`, in Ada, is simply syntactic sugar for `else` followed by `if`. In Ada, the difference is that only one `end if` is needed, if one uses `elseif` instead of `else` followed by `if`. PHP uses the `elseif` keyword[1] both for its curly brackets or colon syntaxes. Perl provides the keyword `elsif` to avoid the large number of braces that would be required by multiple `if` and `else` statements. Python uses the special keyword `elif` because structure is denoted by indentation rather than braces, so a repeated use of `else` and `if` would require increased indentation after every condition. Some implementations of BASIC, such as Visual Basic[2], use `ElseIf` too. Similarly, the earlier UNIX shells (later gathered up to the POSIX shell syntax[3]) use 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 Algol68, Simula, Pascal, BCPL and C, this special syntax for the `else if` construct is not present, nor is it present in the many syntactical derivatives of C, such as Java, ECMAScript, and so on. This works because in these languages, any single statement (in this case `if cond`...) can follow a conditional without being enclosed in a block.

This design choice has a slight "cost" in that code `else if` branch is, effectively, adding an extra nesting level, complicating the job for some compilers (or its implementers), which has to analyse and implement arbitrarily long `else if` chains recursively.

If all terms in the sequence of conditionals are testing the value of a single expression (e.g., `if x=0` ... `else if x=1` ... `else if x=2`...), then an alternative is the switch statement, also called case-statement or select-statement. Conversely, in languages that do not have a switch statement, these can be produced by a sequence of `else if` statements.

### If–then–else expressions

Many languages support if expressions, which are similar to if statements, but return a value as a result. Thus, they are true expressions (which evaluate to a value), not statements (which changes the program state or perform some kind of action).

#### Algol family

ALGOL 60 and some other members of the ALGOL family allow `if–then–else` as an expression:

```  myvariable := if x > 10 then 1 else 2
```

#### Lisp dialects

In dialects of Lisp Scheme, Racket and Common Lisp – the first of which was inspired to a great extent by ALGOL:

```;; Scheme
(define myvariable (if (> x 12) 1 2))   ; Assigns 'myvariable' to 1 or 2, depending on the value of 'x'
```
```;; Common Lisp
(let ((x 10))
(setq myvariable (if (> x 12) 2 4)))  ; Assigns 'myvariable' to 2
```

In Haskell 98, there is only an if expression, no if statement, and the `else` part is compulsory, as every expression must have some value.[4] Logic that would be expressed with conditionals in other languages is usually expressed with pattern matching in recursive functions.

Because Haskell is 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:[5]

```if' :: Bool -> a -> a -> a
if' True x _ = x
if' False _ y = y
```

#### C-like languages

C and C-like languages have a special ternary operator (?:) for conditional expressions with a function that may be described by a template like this:

````condition ? evaluated-when-true : evaluated-when-false`
```

This means that it can be inlined into expressions, unlike if-statements, in C-like languages:

```my_variable = x > 10 ? "foo" : "bar";  // In C-like languages
```

which can be compared to the Algol-family if–then–else expressions (and similar in Ruby and Scala, among others).

To accomplish the same using an if-statement, this would take more than one line of code (under typical layout conventions):

```if (x > 10)
my_variable = "foo";
else
my_variable = "bar";
```

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,[6] while others argue that concise expressions are easier to read than statements spread over several lines.

#### In Small Basic

```x = TextWindow.ReadNumber()
If (x > 10) Then
TextWindow.WriteLine("My variable is named 'foo'.")
Else
TextWindow.WriteLine("My variable is named 'bar'.")
EndIf
```

First, when the user runs the program, a cursor appears waiting for the reader to type a number. If that number is greater than 10, the text "My variable is named 'foo'." is displayed on the screen. If the number is smaller than 10, then the message "My variable is named 'bar'." is printed on the screen.

#### In Visual Basic

In Visual Basic and some other languages, a function called `IIf` 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.

### Arithmetic if

Up to Fortran 77, the language Fortran has an "arithmetic if" statement which is halfway between a computed IF and a case statement, based on the trichotomy x < 0, x = 0, x > 0. This was the earliest conditional statement in Fortran:[7]

```IF (e) label1, label2, label3
```

Where e is any numeric expression (not necessarily an integer); this is equivalent to

```IF (e .LT. 0) GOTO label1
IF (e .EQ. 0) GOTO label2
GOTO label3
```

Because this arithmetic IF is equivalent to multiple `GOTO` statements that could jump to anywhere, it is considered to be an unstructured control statement, and should not be used if more structured statements can be used. In practice it has been observed that most arithmetic `IF` statements referenced the following statement with one or two of the labels.

This was the only conditional control 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.

### Object-oriented implementation in Smalltalk

In contrast to other languages, in Smalltalk the conditional statement is not a language construct but defined in the class `Boolean` as an abstract method that takes two parameters, both closures. `Boolean` has two subclasses, `True` and `False`, which both define the method, `True` executing the first closure only, `False` executing the second closure only.[8]

```var = condition
ifTrue: [ 'foo' ]
ifFalse: [ 'bar' ]
```

### JavaScript

Two examples in JavaScript:

```if (Math.random() < 0.5) {
} else {
console.log("You got Tails!");
}
```
```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!");
}
```

## Lambda Calculus

In Lambda Calculus, the concept of an if-then-else conditional can be expressed using the expressions:

```true = λx. λy. x
false = λx. λy. y
ifThenElse = (λc. λx. λy. (c x y))
```
1. true takes up to two arguments and once both are provided(see currying), it returns the first argument given.
2. false takes up to two arguments and once both are provided(see currying), it returns the second argument given.
3. 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 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 ifThenElse is passed two functions as the left and right conditionals; it is necessary to also pass an empty tuple () to the result of ifThenElse in order to actually call the chosen function, otherwise 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:

``` ((λtrue. λfalse. λifThenElse.
(ifThenElse true 2 3)
)(λx. λy. x)(λx. λy. y)(λc. λl. λr. c l r))
```

Here, true, false, and 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:

``` var computationResult = ((_true => _false => _ifThenElse =>
_ifThenElse(_true)(2)(3)
)(x => y => x)(x => y => y)(c => x => y => c(x)(y)));
```

The code above with multivariable functions looks like this:

``` var computationResult = ((_true, _false, _ifThenElse) =>
_ifThenElse(_true, 2, 3)
)((x, y) => x, (x, y) => y, (c, x, y) => c(x, y));
```

another version of the earlier example without a system where numbers are assumed is below.

First example shows the first branch being taken, while second example shows the second branch being taken.

``` ((λ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))
```

Smalltalk uses a similar idea for its true and false representations, with True and False being singleton objects that respond to messages 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 "if a then b else c" construct which unlike ifThenElse does not compose unless either wrapped in another function or re-implemented as shown in The Haskell section of this page.

## Case and switch statements

Switch statements (in some languages, case statements or multiway branches) compare a given value with specified constants and take action according to the first constant to match. There is usually a provision for a default action ('else','otherwise') to be taken if no match succeeds. Switch statements can allow compiler optimizations, such as lookup tables. In dynamic languages, 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.

Pascal: C: Shell script:
```case someChar of
'a': actionOnA;
'x': actionOnX;
'y','z':actionOnYandZ;
else actionOnNoMatch;
end;
```
```switch (someChar) {
case 'a': actionOnA; break;
case 'x': actionOnX; break;
case 'y':
case 'z': actionOnYandZ; break;
default: actionOnNoMatch;
}
```
```case \$someChar in
a)    actionOnA; ;;
x)    actionOnX; ;;
[yz]) actionOnYandZ; ;;
*)     actionOnNoMatch  ;;
esac
```

## Pattern matching

Pattern matching may be seen as a more sophisticated alternative to both if–then–else, and case statements. It is available in many programming languages with functional programming features, such as Wolfram Language, ML and many others. Here is a simple example written in the OCaml language:

```match fruit with
| "apple" -> cook pie
| "coconut" -> cook dango_mochi
| "banana" -> mix;;
```

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 which illustrates both of these features:

```map _ []      = []
map f (h : t) = f h : map f t
```

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 arrays or comparable data structures, such as Python, Perl, PHP or Objective-C, it is idiomatic to use them to implement conditional assignment.[9]

```pet = raw_input("Enter the type of pet you want to name: ")
known_pets = {
"Dog": "Fido",
"Cat": "Meowsles",
"Bird": "Tweety",
}
my_name = known_pets[pet]
```

In languages that have anonymous functions 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.

## Predication

An alternative to conditional branch instructions is predication. Predication is an 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.

Programming language Structured if switch–select–case Arithmetic if Pattern matching[A]
then else else–if
Ada Yes Yes Yes Yes No No
Bash shell Yes Yes Yes Yes No Yes
C, C++ Yes Yes Unneeded[B] Fall-through No No
C# Yes Yes Unneeded[B] Yes No No
COBOL Yes Yes Unneeded[B] Yes No No
Eiffel Yes Yes Yes Yes No No
F# Yes Yes Yes Unneeded[C] No Yes
Fortran 90 Yes Yes Yes Yes Yes[F] No
Go Yes Yes Unneeded[B] Yes No No
Haskell Yes Needed Unneeded[B] Yes, but unneeded[C] No Yes
Java Yes Yes Unneeded[B] Fall-through[10] No No
ECMAScript (JavaScript) Yes Yes Unneeded[B] Fall-through[11] No No
Mathematica Yes Yes Yes Yes No Yes
Oberon Yes Yes Yes Yes No No
Perl Yes Yes Yes Yes No No
PHP Yes Yes Yes Fall-through No No
Pascal, Object Pascal (Delphi) Yes Yes Unneeded Yes No No
Python Yes Yes Yes No No No
QuickBASIC Yes Yes Yes Yes No No
Ruby Yes Yes Yes Yes No No
Rust Yes Yes Yes Unneeded No Yes
Scala Yes Yes Unneeded[B] Fall-through[citation needed] No Yes
SQL Yes[S] Yes Yes Yes[S] No No
Swift Yes Yes Yes Yes No Yes
Visual Basic, classic Yes Yes Yes Yes No No
Visual Basic .NET Yes Yes Yes Yes No No
Windows PowerShell Yes Yes Yes Fall-through No No
1. ^ 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.
2. 1 2 3 4 5 The often-encountered `else if` 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.
3. 1 2 In Haskell and F#, a separate constant choice construct is unneeded, because the same task can be done with pattern matching.
4. ^ In a Ruby `case` construct, regular expression matching is among the conditional flow-control alternatives available. For an example, see this Stack Overflow question.
5. 1 2 SQL has two similar constructs that fulfill both roles, both introduced in SQL-92. A "searched `CASE`" expression `CASE WHEN cond1 THEN expr1 WHEN cond2 THEN expr2 [...] ELSE exprDflt END` works like `if ... else if ... else`, whereas a "simple `CASE`" expression: `CASE expr WHEN val1 THEN expr1 [...] ELSE exprDflt END` works like a switch statement. For details and examples see Case (SQL).
6. ^ Arithmetic `if` is obsolescent in Fortran 90.

## References

1. ^ PHP elseif syntax
2. ^ Visual Basic ElseIf syntax
3. ^ POSIX standard shell syntax
4. ^ Haskell 98 Language and Libraries: The Revised Report
5. ^
6. ^ "Efficient C Tips #6 – Don't use the ternary operator « Stack Overflow". Embeddedgurus.com. 2009-02-18. Retrieved 2012-09-07.
7. ^ "American National Standard Programming Language FORTRAN". 1978-04-03. Archived from the original on 2007-10-11. Retrieved 2007-09-09.
8. ^ "VisualWorks: Conditional Processing". 2006-12-16. Archived from the original on 2007-10-22. Retrieved 2007-09-09.
9. ^ "Pythonic way to implement switch/case statements". Archived from the original on 2015-01-20. Retrieved 2015-01-19.
10. ^ Java.sun.com, Java Language Specification, 3rd Edition.
11. ^ Ecma-international.org ECMAScript Language Specification, 5th Edition.