GeezerVison

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 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, Java, JavaScript and Visual Basic.

The convention is that an else clause, like the then clause, responds to the nearest preceding if clause. However, the semantics of nested conditionals in some early languages such as ALGOL 60 were less than clear; the syntax was inadequate to always specify the same predicate if clause. Thus, the parser might randomly pair the else with any one of the perhaps manifold if clauses in the intended nested hierarchy.

if A then if B then S else S2

if A then
  if B then
      S
  else 
      S2

if A then (if B then S) else S2 end

if A then
    (if B then S)
else 
    S2
end

if A then (if B then S else S2)

if A then
    (if B then S else S2)
end

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 end if ) or a block enclosure, such as curly brackets ( {⋯} ).

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:

if condition1 then 
  block1
else if condition2 then 
  block2
else if condition3 then 
  block3
  ...
else
  block4
end if

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 "you have to pay $30" is printed. All other statements below that first if statement are skipped.

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

Only one end if is needed if one uses else if instead of else followed by if.

In ALGOL 68, the 1968 “Draft Report” (circulated as a supplement to ALGOL Bulletin no. 26) still used the bold keyword elsf in “contracted” conditionals.^[1] The spelling elif was then standardized in the “Revised Report on the Algorithmic Language ALGOL 68” (1973), which lists both the bold words if ~ then ~ elif ~ else ~ fi and their “brief” symbols, where elif corresponds to |: in the compact form ( ~ | ~ |: ~ | ~ | ~ ).^[2]

In Ada, the elseif keyword is syntactic sugar for the two words else if. PHP also supports an elseif keyword^[3] both for its curly brackets or colon syntaxes. Perl and Ruby provide 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. Visual Basic, supports ElseIf.^[4] Similarly, the earlier UNIX shells (later gathered up to the POSIX shell syntax^[5]) 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 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.

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 ...), 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.

ALGOL 60 and some other members of the ALGOL family allow if–then–else 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:

myvariable := if x > 20 then 1 else 2

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 BEGIN and END in embedded 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
  );

Conditional expressions have always been a fundamental part of Lisp . In pure LISP, the COND function is used. In dialects such as Scheme, Racket and Common Lisp :

;; Scheme
(define (myvariable x) (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.^[8] 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:^[9]

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

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, and to "bar" if not.

r = x > 10 ? "foo" : "bar";

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

if (x > 10)
    r = "foo";
else
    r = "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,^[10] while others argue that concise expressions are easier to read and better since they have less repeated clauses.

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.

In Tcl if is not a keyword but a function (in Tcl known as command or proc). For example

if {$x > 10} {
    puts "Foo!"
}

invokes a function named if 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 if function receives the condition as a string value and is responsible to evaluate this string as an expression in the callers scope.^[11]

Such a behavior is possible by using uplevel and expr 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).^[12]

Because if 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.^[13]

In Rust, if is always an expression. It evaluates to the value of whichever branch is executed, or to the unit type () if no branch is executed. If a branch does not provide a return value, it evaluates to () by default. To ensure the if expression's type is known at compile time, each branch must evaluate to a value of the same type. For this reason, an else branch is effectively compulsory unless the other branches evaluate to (), because an if without an else can always evaluate to () by default.^[14]

The following assigns r to 1 or 2 depending on the value of x.

let r = if x > 20 {
    1
} else {
    2
};

Values can be omitted when not needed.

if x > 20 {
    println!("x is greater than 20");
}