Conditional structures: Difference between revisions
m (added a ;Task: (bold) header, added other whitespace to the task's preamble.) |
(→{{header|Perl}}: improve style, language, formatting) |
||
| Line 3,303: | Line 3,303: | ||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
{{works with|Perl|5}} |
{{works with|Perl|5}} |
||
===if/else=== |
===if/else=== |
||
| ⚫ | |||
| ⚫ | |||
}; |
|||
| ⚫ | |||
| ⚫ | |||
| ⚫ | |||
| ⚫ | |||
}</lang> |
|||
| ⚫ | |||
| ⚫ | |||
| ⚫ | |||
| ⚫ | |||
| ⚫ | |||
| ⚫ | |||
| ⚫ | |||
| ⚫ | |||
}; |
|||
} |
|||
| ⚫ | |||
| ⚫ | |||
}</lang> |
|||
| ⚫ | |||
| ⚫ | |||
} |
|||
| ⚫ | |||
| ⚫ | |||
} |
|||
| ⚫ | |||
| ⚫ | |||
}</lang> |
|||
| ⚫ | |||
| ⚫ | |||
| ⚫ | |||
| ⚫ | |||
| ⚫ | |||
| ⚫ | |||
}; |
|||
===unless=== |
===unless=== |
||
| ⚫ | |||
<code>unless</code> behaves like <code>if</code>, only logically negated. |
|||
| ⚫ | |||
===ternary operator=== |
===ternary operator=== |
||
The ternary operator is used as an expression within a statement, rather than as a control flow structure containing one or more statements. It is frequently used in assignment, or sometimes for passing function call arguments that vary depending on some condition. |
The ternary operator is used as an expression within a statement, rather than as a control flow structure containing one or more statements. It is frequently used in assignment, or sometimes for passing function call arguments that vary depending on some condition. |
||
<lang perl>$variable = $expression ? $value_for_true : $value_for_false;</lang> |
|||
===logical operators=== |
===logical operators=== |
||
| ⚫ | |||
< |
<lang perl>$condition and do_something; # equivalent to $condition ? do_something : $condition</lang> |
||
| ⚫ | |||
<code>&&</code> and <code>||</code> have the same semantics as <code>and</code> and <code>or</code>, respectively, but their precedence is much higher, making them better for conditional expressions than control flow. |
<code>&&</code> and <code>||</code> have the same semantics as <code>and</code> and <code>or</code>, respectively, but their precedence is much higher, making them better for conditional expressions than control flow. |
||
===switch=== |
===switch=== |
||
At |
At first there was no ''switch'' structure in Perl, although there were plenty ways to emulate it. In Perl 5.8, an experimental <code>switch</code>/<code>case</code>/<code>else</code> structure was introduced. Perl 5.10 replaced this with the <code>given</code>/<code>when</code>/<code>default</code> structure borrowed from Perl 6. |
||
{{works with|Perl|5.10}} |
{{works with|Perl|5.10}} |
||
Revision as of 08:05, 30 July 2016
You are encouraged to solve this task according to the task description, using any language you may know.
These are examples of control structures. You may also be interested in:
- Task
List the conditional structures offered by a programming language.
Common conditional structures are if-then-else and switch.
360 Assembly
Here are the branch mnemonic opcodes: <lang 360asm>* Unconditional Branch or No Branch:
B label Unconditional
BR Rx "
NOP label No Operation
NOPR Rx "
- After Compare Instructions
BH label Branch on High
BHR Rx "
BL label Branch on Low
BLR Rx "
BE label Branch on Equal
BER Rx "
BNH label Branch on Not High
BNHR Rx "
BNL label Branch on Not Low
BNLR Rx "
BNE label Branch on Not Equal
BNER Rx "
- After Arithmetic Instructions:
BP label Branch on Plus
BPR Rx "
BM label Branch on Minus
BMR Rx "
BZ label Branch on Zero
BZR Rx "
BO label Branch on Overflow
BOR Rx "
BNP label Branch on Not Plus
BNPR Rx "
BNM label Branch on Not Minus
BNMR Rx "
BNZ label Branch on Not Zero
BNZR Rx "
BNO label Branch on No Overflow
BNOR Rx "
- After Test Under Mask Instructions:
BO label Branch if Ones
BOR Rx "
BM label Branch if Mixed
BMR Rx "
BZ label Branch if Zero
BZR Rx "
BNO label Branch if Not Ones
BNOR Rx "
BNM label Branch if Not Mixed
BNMR Rx "
BNZ label Branch if Not Zero
BNZR Rx "</lang>
The ASM (Assembler Structured Macros) toolkit brings structures to IBM assembler 360. <lang 360asm> expression:
opcode,op1,rel,op2
opcode,op1,rel,op2,OR,opcode,op1,rel,op2
opcode,op1,rel,op2,AND,opcode,op1,rel,op2
opcode::=C,CH,CR,CLC,CLI,CLCL, LTR, CP,CE,CD,...
rel::=EQ,NE,LT,LE,GT,GE, (fortran style)
E,L,H,NE,NL,NH (assembler style)
P (plus), M (minus) ,Z (zero) ,O (overflow)
opcode::=CLM,TM
rel::=O (ones),M (mixed) ,Z (zeros)
- IF
IF expression [THEN]
...
ELSEIF expression [THEN]
...
ELSE
...
ENDIF
IF C,R4,EQ,=F'10' THEN if r4=10 then
MVI PG,C'A' pg='A'
ELSEIF C,R4,EQ,=F'11' THEN elseif r4=11 then
MVI PG,C'B' pg='B'
ELSEIF C,R4,EQ,=F'12' THEN elseif r4=12 then
MVI PG,C'C' pg='C'
ELSE else
MV PG,C'?' pg='?'
ENDIF end if
- SELECT
SELECT expressionpart1
WHEN expressionpart2a
...
WHEN expressionpart2b
...
OTHRWISE
...
ENDSEL
- example SELECT type 1
SELECT CLI,HEXAFLAG,EQ select hexaflag=
WHEN X'20' when x'20'
MVI PG,C'<' pg='<'
WHEN X'21' when x'21'
MVI PG,C'!' pg='!'
WHEN X'22' when x'21'
MVI PG,C'>' pg='>'
OTHRWISE otherwise
MVI PG,C'?' pg='?'
ENDSEL end select
- example SELECT type 2
SELECT select
WHEN C,DELTA,LT,0 when delta<0
MVC PG,=C'0 SOL' pg='0 SOL'
WHEN C,DELTA,EQ,0 when delta=0
MVC PG,=C'1 SOL pg='0 SOL'
WHEN C,DELTA,GT,0 when delta>0
MVC PG,=C'2 SOL pg='0 SOL'
ENDSEL end select
- CASE
CASENTRY R4 select case r4
CASE 1 case 1
LA R5,1 r5=1
CASE 3 case 3
LA R5,2 r5=2
CASE 5 case 5
LA R5,3 r5=1
CASE 7 case 7
LA R5,4 r5=4
ENDCASE end select</lang>
6502 Assembly
6502 Assembly has 8 conditional branch instructions; each instruction will test the appropriate flag and condition and jump between -128 and 127 bytes. To understand these conditional instructions, it is helpful to remember that the comparison instructions (CMP, CPX, CPY) set the flags as if a subtraction had occurred: <lang 6502asm> LDA #10 CMP #11</lang> Following these instructions, the accumulator will still hold 10 but the flags are set as if you had instructed the processor to perform 10 - 11. The result is -1, so the sign flag will be set, the zero flag will be cleared, the overflow flag will be cleared, and the carry flag will be set. <lang 6502asm> BNE ;Branch on Not Equal - branch when the zero flag is set BEQ ;Branch on EQual - branch when the zero flag is set. ;The zero flag is set when the result of an operation is zero
BMI ;Branch on MInus BPL ;Branch on PLus - branch when the sign flag is cleared/set. ;The sign flag is set when the result of an instruction is a negative number ;and cleared when the result is a positive number
BVS ;Branch on oVerflow Set BVC ;Branch on oVerflow Cleared - branch when the overflow flag is cleared/set. ;The overflow flag is set when the result of an addition/subtraction would ;result in a number larger than 127 or smaller than -128
BCS ;Branch on Carry Set BCC ;Branch on Carry Clear - branch when the carry flag is cleared/set. ;The carry flag is set when an addition produced a carry and when ;a subtraction produced a borrow and cleared if an addition/subtraction ;does not produce a carry/borrow. The carry flag also holds bits ;after shifts and rotates.</lang> In the following example, the branch will be taken if memory location Variable holds 200: <lang 6502asm> LDA #200 CMP Variable BEQ #3 ;if equal, skip ahead 3 bytes... CLC ;if unequal, continue executing instructions ADC #1 STA OtherVariable ; ...to here.</lang> Because you don't have to perform a comparison to set the flags, you can perform very fast checks in interative loops: <lang 6502asm> LDX #100 Loop: ...do something DEX BNE Loop</lang> This code will loop until X is zero. Most assemblers will figure out the correct offset for you if you use a label in place of the offset after a branch instruction, as in the above example.
ActionScript
- See JavaScript
Ada
if-then-else
<lang ada>type Restricted is range 1..10; My_Var : Restricted;
if My_Var = 5 then
-- do something
elsif My_Var > 5 then
-- do something
else
-- do something
end if;</lang>
case with a default alternative
<lang ada>type Days is (Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday); Today : Days;
case Today is
when Saturday | Sunday =>
null;
when Monday =>
Compute_Starting_Balance;
when Friday =>
Compute_Ending_Balance;
when others =>
Accumulate_Sales;
end case;</lang>
case without a default
When there is no when others clause, the compiler will complain about any uncovered alternative. This defends against a common reason for bugs in other languages. I.e., the following code is syntactically incorrect:
<lang ada>case Today is
when Monday =>
Compute_Starting_Balance;
when Friday =>
Compute_Ending_Balance;
when Tuesday .. Thursday =>
Accumulate_Sales;
-- ignore Saturday and Sunday
end case;</lang>
The syntactically correct version:
<lang ada>case Today is
when Saturday | Sunday =>
null; -- don't do anything, if Today is Saturday or Sunday
when Monday =>
Compute_Starting_Balance;
when Friday =>
Compute_Ending_Balance;
when Tuesday .. Thursday =>
Accumulate_Sales;
end case;</lang>
select
Select provides conditional acceptance of entry calls. Select can also be used to conditionally call an entry
Conditional Accept
<lang ada>select
accept first_entry; -- do something or accept second_entry; -- do something or terminate;
end select;</lang>
Conditional entry call
A selective entry call provides a way to time-out an entry call. Without the time-out the calling task will suspend until the entry call is accepted. <lang ada>select
My_Task.Start;
or
delay Timeout_Period;
end select;</lang> The entry Start on the task My_Task will be called. If My_Task accepts the entry call before the timer expires the timer is canceled. If the timeout expires before the entry call is accepted the entry call is canceled.
Aikido
Conditional Expressions
<lang aikido> var x = loggedin ? sessionid : -1
</lang>
if..elif..else
<lang aikido> if (value > 40) {
println ("OK")
} elif (value < 20) {
println ("FAILED")
} else {
println ("RETRY")
} </lang>
switch
<lang aikido> switch (arg) { case "-d": case "--debug":
debug = true break
case "-f":
force = true break
default:
throw "Unknown option " + arg
}
switch (value) { case > 40:
println ("OK")
break
case < 20:
println ("FAILED")
break
case in 50..59:
println ("WIERD")
// fall through
default:
println ("RETRY")
} </lang>
Aime
If-elif-else
<lang aime>if (c1) {
// first condition is true...
} elif (c2) {
// second condition is true...
} elif (c3) {
// third condition is true...
} else {
// none was true...
}</lang>
ALGOL 60
Algol 60 has invented the famous if then else block structure. Algol 60 has conditional expressions of the form:
expression::= if conditional_expression then expression else expression K:=if X=Y then I else J
Algol 60 has conditional statements of the form:
statement::= if conditional_expression then statement else statement if X=Y then K:=I else K:=J statement::= if conditional_expression then statement if X=Y then K:=I
An example: <lang algol60> 'IF' I=1 'THEN' OUTINTEGER(1,I);
'IF' I<J 'THEN' OUTSTRING(1,'(' : I<J')')
'ELSE' OUTSTRING(1,'(' : I>=J')');
'IF' I>=J 'THEN' 'BEGIN'
OUTSTRING(1,'(' I=')');
OUTINTEGER(1,I)
'END'
'ELSE' 'BEGIN'
OUTSTRING(1,'(' J=')');
OUTINTEGER(1,J)
'END'</lang>
Algol 60 has also a switch structure:
declaration::= switch switch:=list_of labels statement::= goto switch[expression]
An example: <lang algol60> 'SWITCH' TARGET:=L1,L2,L3;
...
'GOTO' TARGET(/J/);
L1: OUTSTRING(1,'('AA')');
L2: OUTSTRING(1,'('BB')');
L3: OUTSTRING(1,'('CC')');</lang>
ALGOL 68
See Conditional Structures/ALGOL 68
ALGOL W
<lang algolw>begin
integer a, b, c;
a := 1; b := 2; c := 3;
% algol W has the traditional Algol if-the-else statement %
% there is no "elseif" contraction %
if a = b
then write( "a = b" )
else if a = c
then write( "a = c" )
else write( "a is ", a );
% if-then-else can also be used in an expression % write( if a < 4 then "lt 4" else "ge 4" );
% algol W also has a "case" statement, an integer expression is used to %
% select the statement to execute. If the expression evaluates to 1, %
% the first statement is executed, if 2, the second is executed etc. %
% If the expression is less than 1 or greater than the number of %
% statements, a run time error occurs %
case a + b of
begin write( "a + b is one" )
; write( "a + b is two" )
; write( "a + b is three" )
; write( "a + b is four" )
end;
% there is also an expression form of the case: % write( case c - a of ( "one", "two", "three", "four" ) )
end.</lang>
- Output:
a is 1 lt 4 a + b is three two
AmbientTalk
If-then-else
In AmbientTalk, if:then:else: is a keyworded message (as in Smalltalk). The first argument should be a boolean expression. The second and third arguments should be blocks (aka anonymous functions or thunks).
<lang ambienttalk> if: condition then: {
// condition is true...
} else: {
// condition is false...
} </lang>
IfTrue/IfFalse
One can also send a message to the boolean objects true and false:
<lang ambienttalk> condition.ifTrue: { /* condition is true... */ } ifFalse: { /* condition is false... */ } </lang>
AmigaE
IF-THEN-ELSE <lang amigae>IF condition
-> if condition is true...
ELSEIF condition2
-> else if condition2 is true...
ELSE
-> if all other conditions are not true...
ENDIF</lang>
or on one single line:
<lang amigae>IF condition THEN statement</lang>
Ternary IF THEN ELSE
The IF-THEN-ELSE can be used like ternary operator (?: in C) <lang amigae>DEF c c := IF condition THEN 78 ELSE 19</lang>
SELECT-CASE
<lang amigae>SELECT var
CASE n1 -> code CASE n2 -> code DEFAULT -> no one of the previous case...
ENDSELECT</lang>
Another version allows for ranges:
<lang amigae>SELECT max_possible_value OF var
CASE n1 -> code CASE n2 TO n3, n4 -> more CASE n5 TO n6, n7 TO n8 -> more... DEFAULT -> none of previous ones
ENDSELECT</lang>
The biggest among n1, n2 and so on, must be not bigger than max_possible_value.
Apex
if-then-else
<lang java>if (s == 'Hello World') {
foo();
} else if (s == 'Bye World') {
bar();
} else {
deusEx();
}</lang> Java also supports short-circuit evaluation. So in a conditional like this: <lang java>if(obj != null && obj.foo()){
aMethod();
}</lang> obj.foo() will not be executed if obj != null returns false. It is possible to have conditionals without short circuit evaluation using the & and | operators (from Bitwise operations). So in this conditional: <lang java>if(obj != null & obj.foo()){
aMethod();
}</lang> You will get a null pointer exception if obj is null.
ternary
<lang java>s == 'Hello World' ? foo() : bar();</lang>
switch
Apex does not support switch / case statements.
AppleScript
if-then-else
<lang applescript>if myVar is "ok" then return true
set i to 0 if i is 0 then
return "zero"
else if i mod 2 is 0 then
return "even"
else
return "odd"
end if</lang>
AutoHotkey
if, else if, else
<lang AutoHotkey>x = 1 If x
MsgBox, x is %x%
Else If x > 1
MsgBox, x is %x%
Else
MsgBox, x is %x%</lang>
ternary if
<lang AutoHotkey>x = 2 y = 1 var := x > y ? 2 : 3 MsgBox, % var
while (looping if)
<lang AutoHotkey>While (A_Index < 3) {
MsgBox, %A_Index% is less than 3
}</lang>
AutoIt
If, ElseIf, Else
<lang AutoIt>If <expression> Then
statements ...
[ElseIf expression-n Then
[elseif statements ... ]] ...
[Else
[else statements] ...
EndIf </lang>
Select Case
<lang AutoIt>Select
Case <expression>
statement1
...
[Case
statement2
...]
[Case Else
statementN
...]
EndSelect </lang>
Switch Case
<lang AutoIt>Switch <expression>
Case <value> [To <value>] [,<value> [To <value>] ...]
statement1
...
[Case <value> [To <value>] [,<value> [To <value>] ...]
statement2
...]
[Case Else
statementN
...]
EndSwitch </lang> --BugFix (talk) 15:39, 13 November 2013 (UTC)
AWK
Conditionals in awk are modelled after C: <lang awk>if(i<0) i=0; else i=42</lang> For a branch with more than a single statement, this needs braces: <lang awk> if(i<0) {
i=0; j=1
} else {
i=42; j=2
}</lang>
There is also the ternary conditional: <lang awk>i=(i<0? 0: 42)</lang>
Axe
Expressions that evaluate to zero are considered false. Expressions that evaluate to nonzero are considered true.
Simple
<lang axe>If 1
YEP()
End</lang>
Inverse If
<lang axe>!If 1
NOPE()
End</lang>
If-Else
<lang axe>If 1
YEP()
Else
NOPE()
End</lang>
Axe has no support for switch-like statements. If-ElseIf-Else structures are required to achieve the same goal.
If-ElseIf-Else
<lang axe>If 1=0
NOPE()
ElseIf 1=1
YEP()
Else
NOPE()
End</lang>
If-InverseElseIf-Else
<lang axe>If 1=0
NOPE()
Else!If 1=2
YEP()
Else
NOPE()
End</lang>
Babel
Simple select
<lang babel> "foo" "bar" 3 4 > sel << </lang>
Prints "foo" since '3 4 >' evaluates to false, which causes sel to remove "bar" from the stack.
If-Then-Else
<lang babel>
{3 4 >}
{"foo"}
{"bar"}
ifte
<<
</lang>
Prints "bar" because the first line is the "if", the second line is the "then" and the last line is the "else", and '3 4 >' evaluates to false.
Conditional
<lang babel>
({3 4 >} {"Three is greater than four" }
{3 3 >} {"Three is greater than three"}
{3 2 >} {"Three is greater than two" }
{3 1 >} {"Three is greater than one" })
cond
<<
</lang>
Prints "Three is greater than two", as expected.
BASIC
if-then-else
BASIC can use the if statement to perform conditional operations:
<lang basic>10 LET A%=1: REM A HAS A VALUE OF TRUE 20 IF A% THEN PRINT "A IS TRUE" 30 WE CAN OF COURSE USE EXPRESSIONS 40 IF A%<>0 THEN PRINT "A IS TRUE" 50 IF NOT(A%) THEN PRINT "A IS FALSE" 60 REM SOME VERSIONS OF BASIC PROVIDE AN ELSE KEYWORD 70 IF A% THEN PRINT "A IS TRUE" ELSE PRINT "A IS FALSE"</lang>
Here are code snippets from a more modern variant that does not need line numbers:
Single line IF does not require END IF
<lang qbasic>IF x = 0 THEN doSomething IF x < 0 THEN doSomething ELSE doOtherThing</lang>
Multi-line IF:
<lang qbasic>IF x > 0 AND x < 10 THEN
'do stuff
ELSE IF x = 0 THEN
'do other stuff
ELSE
'do more stuff
END IF</lang>
Like in C, any non-zero value is interpreted as True:
<lang qbasic>IF aNumber THEN
'the number is not 0
ELSE
'the number is 0
END IF</lang>
select case
The condition in each case branch can be one or more constants or variables, a range or an expression.
<lang qbasic>SELECT CASE expression CASE 1
'do stuff
CASE 2, 3
'do other stuff
CASE 3.1 TO 9.9
'do this
CASE IS >= 10
'do that
CASE ELSE
'default case
END SELECT</lang>
Computed ON-GOTO
Older line-numbered BASICs had a mechanism for vectoring execution based on the contents of a numeric variable (a low-budget case statement).
ON V GOTO 120,150,150,170
or:
<lang basic>10 INPUT "Enter 1,2 or 3: ";v 20 GOTO v * 100 99 STOP 100 PRINT "Apple" 110 STOP 200 PRINT "Banana" 210 STOP 300 PRINT "Cherry" 310 STOP</lang>
Conditional loops
Some variants of basic support conditional loops:
<lang bbcbasic>10 REM while loop 20 L=0 30 WHILE L<5 40 PRINT L 50 L=L+1 60 WEND 70 REM repeat loop 80 L=1 90 REPEAT 100 PRINT L 110 L=L+1 120 UNTIL L>5</lang>
BBC BASIC
<lang bbcbasic> REM Single-line IF ... THEN ... ELSE (ELSE clause is optional):
IF condition% THEN statements ELSE statements
REM Multi-line IF ... ENDIF (ELSE clause is optional):
IF condition% THEN
statements
ELSE
statements
ENDIF
REM CASE ... ENDCASE (OTHERWISE clause is optional):
CASE expression OF
WHEN value1: statements
WHEN value2: statements
...
OTHERWISE: statements
ENDCASE
REM ON ... GOTO (ELSE clause is optional):
ON expression% GOTO dest1, dest2 ... ELSE statements
REM ON ...GOSUB (ELSE clause is optional):
ON expression% GOSUB dest1, dest2 ... ELSE statements
REM ON ... PROC (ELSE clause is optional):
ON expression% PROCone, PROCtwo ... ELSE statements</lang>
beeswax
beeswax has 4 conditional operators that act like the ternary ?: operator in C or Julia. Due to the 2-dimensional nature of beeswax it is possible to realize complex branching structures this way.
The 4 conditional operators are: <lang Beeswax> ' lstack top value == 0 ? skip next instruction : don’t skip next instruction. " lstack top value > 0 ? skip next instruction : don’t skip next instruction. K lstack top value == 2nd value ? skip next instruction : don’t skip next instruction. L lstack top value > 2nd value ? skip next instruction : don’t skip next instruction.</lang>
Example: <lang Beeswax>_`Enter integer n:`T'p`n = 0`>N`Enter integer m:`T'p`m = 0`>` and `Kp`m = n`;
>`n > 0`d >`m > 0`d >Lp`m > n`;
>`m < n`;</lang>
Example output: <lang Beeswax>Enter integer n: i3 n > 0 Enter integer m: i0 m = 0 and m < n</lang>
Befunge
Befunge only has one conditional structure, which comes in two flavors: vertical IF ( | ) and horizontal IF ( _ ). Befunge only has two boolean commands, greater-than ( ` ) and not ( ! ). These snippets input a number and use the conditional operators to print a "0" if it is zero and an "X" otherwise.
<lang befunge>v > "X",@ non-zero > & |
> "0",@ zero</lang>
# is the skip command. It unconditionally skips one character, allowing a little flexibility in flow control.
<lang befunge>& #v_ "0",@ zero
> "X",@ non-zero</lang>
Bori
if-elif-else
<lang bori> if (i == 0)
return "zero";
elif (i % 2)
return "odd";
else
return "even";
</lang>
Bracmat
"if .. then .. else .." type of branching
Bracmat uses & and | for branching. These binary operators are like && and || in C-like languages. Bracmat does not have the notion of Boolean variables, but marks all evaluated expressions as either succeeded or failed. If the left hand side of the & operator has succeeded, Bracmat goes on evaluating the right hand side. Only if both of left and right hand sides succeed, the expression tree headed by the & operator as a whole succeeds. Likewise, only if both of left and right hand sides of an expression tree headed by | fail, the expression tree as a whole fails. Evaluated expressions are just that: expressions. The following expression writes "That's what I thought." to your screen and evaluates to the expression "Right".
<lang bracmat> 2+2:5
& put$"Strange, must check that Bracmat interpreter." & 0
| put$"That's what I thought."
& Right</lang>
switch-like branching
Use a patterns with alternations. Note that the match-expression (the tree headed by the : operator) evaluates to the left hand side of the : operator. In the following example, the resulting expression is a single node containing "4".
<lang bracmat> 2+2
- ( (<3|>5)
& put$"Not quite, must check that Bracmat interpreter." | (3|5) & put$"Not far off, but must check that Bracmat interpreter some day." | ? & put$"That's what I thought." ) </lang>
Brainf***
Brainf*** has two conditional jump instructions, [ and ]. the [ instruction jumps forward to the corresponding ] instruction if the value at the current memory cell is zero, while the ] instruction jumps back if the current memory cell is nonzero. Thus in the following sequence:
<lang bf>[.]</lang>
The . instruction will be skipped, while the following sequence
<lang bf>+[.]</lang>
will result in an infinite loop. Finally, in the following sequence
<lang bf>+[.-]</lang>
The . instruction will be executed once.
Burlesque
Using the Choose command:
<lang burlesque> blsq ) 9 2.%{"Odd""Even"}ch "Odd" </lang>
Using the If command (produce next even number if odd):
<lang burlesque> blsq ) 9^^2.%{+.}if 10 blsq ) 10^^2.%{+.}if 10 </lang>
Using the IfThenElse command (produce next odd number if even or previous even number if odd):
<lang burlesque> blsq ) 10^^2.%{-.}\/{+.}\/ie 11 blsq ) 9^^2.%{-.}\/{+.}\/ie 8 </lang>
Emulating Switch-Case behaviour:
<lang burlesque> blsq ) {"Hate tomatos" "Like Bananas" "Hate Apples"}{"Tomato" "Banana" "Apple"}"Banana"Fi!! "Like Bananas" blsq ) {"Hate tomatos" "Like Bananas" "Hate Apples"}{"Tomato" "Banana" "Apple"}"Apple"Fi!! "Hate Apples" </lang>
C
C++
Run-Time Control Structures
- See C
Compile-Time Control Structures
Preprocessor Techniques
- See C
Template metaprogramming
Selecting a type depending on a compile time condition
<lang cpp>template<bool Condition, typename ThenType, typename Elsetype> struct ifthenelse;
template<typename ThenType, typename ElseType> struct ifthenelse<true, ThenType, ElseType> {
typedef ThenType type;
};
template<typename ThenType, typename ElseType> struct ifthenelse<false, ThenType, ElseType> {
typedef ElseType type;
};
// example usage: select type based on size ifthenelse<INT_MAX == 32767, // 16 bit int?
long int, // in that case, we'll need a long int
int> // otherwise an int will do
::type myvar; // define variable myvar with that type</lang>
Clean
if
There are no then or else keyword in Clean. The second argument of if is the then-part, the third argument is the else-part. <lang clean>bool2int b = if b 1 0</lang>
case-of
<lang clean>case 6 * 7 of
42 -> "Correct" _ -> "Wrong" // default, matches anything</lang>
function alternatives
<lang clean>answer 42 = True answer _ = False</lang>
guards
<lang clean>answer x
| x == 42 = True | otherwise = False
case 6 * 7 of
n | n < 0 -> "Not even close" 42 -> "Correct" // no default, could result in a run-time error</lang>
Clipper
if-elseif-else-endif <lang clipper>IF x == 1
SomeFunc1()
ELSEIF x == 2
SomeFunc2()
ELSE
SomeFunc()
ENDIF</lang>
do case <lang clipper>DO CASE CASE x == 1
SomeFunc1()
CASE x == 2
SomeFunc2()
OTHERWISE
SomeFunc()
ENDCASE</lang>
Clojure
if-then-else
<lang clojure>(if (= 1 1) :yes :no) ; returns :yes
(if (= 1 2) :yes :no) ; returns :no
(if (= 1 2) :yes) ; returns nil</lang>
when
Similar to if, but body in an implicit do block allowing multiple statements.
No facility for providing an else. when is defined as a macro.
<lang clojure>(when x
(print "hello") (println " world") 5) ; when x is logical true, prints "hello world" and returns 5; otherwise does nothing, returns nil</lang>
cond
The cond macro takes a series of test/result pairs, evaluating each test until one resolves to logical true, then evaluates its result. Returns nil if none of the tests yield true. <lang clojure>(cond
(= 1 2) :no) ; returns nil
(cond
(= 1 2) :no (= 1 1) :yes) ; returns :yes</lang>
Since non-nil objects are logical true, by convention the keyword :else is used to yield a default result. <lang clojure>(cond
(= 1 2) :no :else :yes) ; returns :yes</lang>
condp
Similar to cond, but useful when each test differs by only one variant. <lang clojure>(condp < 3
4 :a ; cond equivalent would be (< 4 3) :a 3 :b 2 :c 1 :d) ; returns :c</lang>
Optionally takes a final arg to be used as the default result if none of the tests match. <lang clojure>(condp < 3
4 :a 3 :b :no-match) ; returns :no-match</lang>
case
<lang clojure>(case 2
0 (println "0") 1 (println "1") 2 (println "2")) ; prints 2.</lang>
CMake
<lang cmake>set(num 5)
if(num GREATER 100)
message("${num} is very large!")
elseif(num GREATER 10)
message("${num} is large.")
else()
message("${num} is small.")
message("We might want a bigger number.")
endif()</lang>
The if() and elseif() commands evaluate boolean expressions like num GREATER 100; refer to cmake --help-command if. The elseif() and else() sections are optional.
COBOL
if-then-else
<lang cobol>if condition-1
imperative-statement-1
else
imperative-statement-2
end-if
if condition-1
if condition-a
imperative-statement-1a
else
imperative-statement-1
end-if
else
if condition-a
imperative-statement-2a
else
imperative-statement-2
end-if
end-if</lang>
evaluate
<lang cobol>evaluate identifier-1 when 'good'
good-imperative-statement
when 'bad'
bad-imperative-statement
when 'ugly' when 'awful'
ugly-or-awful-imperative-statement
when other
default-imperative-statement
end-evaluate
evaluate true when condition-1
condition-1-imperative-statement
when condition-2
condition-2-imperative-statement
when condition-3
condition-3-imperative-statement
when other
default-condition-imperative-statement
end-evaluate
evaluate identifier-1 also identifier-2 when 10 also 20
one-is-10-and-two-is-20-imperative-statement
when 11 also 30
one-is-11-and-two-is-30-imperative-statement
when 20 also any
one-is-20-and-two-is-anything-imperative-statement
when other
default-imperative-statement
end-evaluate</lang>
CoffeeScript
if-then-else
<lang coffeescript> if n == 1
console.log "one"
else if n == 2
console.log "two"
else
console.log "other"
</lang>
switch
<lang coffeescript>n = 1
switch n
when 1 console.log "one" when 2, 3 console.log "two or three" else console.log "other"
</lang>
ternary expressions
CoffeeScript is very expression-oriented, so you can assign the "result" of an if-then to a variable.
<lang coffeescript>s = if condition then "yup" else "nope"
- alternate form
s = \
if condition then "yup" else "nope"</lang>
ColdFusion
if-elseif-else
Compiler: ColdFusion any version <lang cfm><cfif x eq 3>
do something
<cfelseif x eq 4>
do something else
<cfelse>
do something else
</cfif></lang>
switch
Compiler: ColdFusion any version <lang cfm><cfswitch expression="#x#">
<cfcase value="1"> do something </cfcase> <cfcase value="2"> do something </cfcase> <cfdefaultcase> do something </cfdefaultcase>
</cfswitch></lang>
Comal
IF/THEN
<lang Comal>IF condition THEN PRINT "True"</lang>
IF/THEN/ELSE
<lang Comal>IF condition THEN
PRINT "True"
ELSE
PRINT "False"
ENDIF</lang>
IF/THEN/ELIF/ELSE
<lang Comal>IF choice=1 THEN
PRINT "One"
ELIF choice=2 THEN
PRINT "Two"
ELSE
Print "None of the above"</lang>
CASE/WHEN
<lang Comal> CASE choice OF WHEN 1
PRINT "One"
WHEN 2
PRINT "Two"
OTHERWISE
PRINT "Some other choice"
ENDCASE </lang>
Common Lisp
There are 2 main conditional operators in common lisp, (if ...) and (cond ...).
(if cond then [else])
The (if ...) construct takes a predicate as its first argument and evaluates it. Should the result be non-nil, it goes on to evaluate and returnm the results of the 'then' part, otherwise, when present, it evaluates and returns the result of the 'else' part. Should there be no 'else' part, it returns nil.
<lang lisp>(if (= val 42)
"That is the answer to life, the universe and everything" "Try again") ; the else clause here is optional</lang>
when and unless
Common Lisp also includes (when condition form*) and (unless condition form*) which are equivalent, respectively, to (if condition (progn form*)) and (if (not condition) (progn form*)).
It is unidiomatic to use if without an else branch for side effects; when should be used instead.
(cond (pred1 form1) [... (predN formN)])
The (cond ...) construct acts as both an if..elseif...elseif...else operator and a switch, returning the result of the form associated with the first non-nil predicate.
<lang lisp>(cond ((= val 1) (print "no"))
((and (> val 3) (< val 6)) (print "yes"))
((> val 99) (print "too far"))
(T (print "no way, man!")))</lang>
Crack
if-elseif-else
<lang crack>if (condition) {
// Some Task
}
if (condition) {
// Some Task
} else if (condition2) {
// Some Task
} else {
// Some Task
}</lang>
Ternary
<lang crack> // if condition is true var will be set to 1, else false. int var = condition ? 1 : 2; </lang>
C#
if-elseif-else
<lang csharp>if (condition) {
// Some Task
}
if (condition) {
// Some Task
} else if (condition2) {
// Some Task
} else {
// Some Task
}</lang>
Ternary
<lang csharp>// if condition is true var will be set to 1, else 2. int var = condition ? 1 : 2;</lang>
switch
<lang csharp>switch (value) {
case 1:
// Some task
break; // Breaks are required in C#.
case 2:
case 3:
// Some task
break;
default: // If no other case is matched.
// Some task
break;
}</lang>
If fall through algorithms are required use the goto keyword.
<lang csharp>switch (value) {
case 1:
// Some task
goto case 2; // will cause the code indicated in case 2 to be executed.
case 2:
// Some task
break;
case 3:
// Some task
break;
default: // If no other case is matched.
// Some task
break;
}</lang>
Batch File
IF syntax: <lang dos> IF [NOT] ERRORLEVEL number command IF [NOT] string1==string2 command IF [NOT] EXIST filename command IF CMDEXTVERSION number command IF DEFINED variable command IF [/I] string1 compare-op string2 command
where compare-op is: EQU - equal NEQ - not equal LSS - less than LEQ - less than or equal GTR - greater than GEQ - greater than or equal /I case insensitive string compares
</lang> The ELSE clause must be on the same line as the command after the IF. For example: <lang dos> IF EXIST %filename% (
del %filename%
) ELSE (
echo %filename% not found
) </lang>
D
- See C, sans the preprocessor.
<lang d>void main() {
enum int i = 5;
// "static if" for various static checks:
static if (i == 7) {
// ...
} else {
//...
}
// is(T == U) checks if type T is U.
static if (is(typeof(i) == int)) {
// ...
} else {
// ...
}
// D switch is improved over C switch:
switch (i) {
case 0:
break; // Silent fallthrough is forbidden.
case 1:
goto case; // Explicit fallthrough.
case 2:
// Empty cases don't require an explicit fallthrough.
case 3:
return;
case 4, 5, 7: // Multiple cases.
break;
case 8: .. case 15: // Inclusive interval.
goto case 3;
default: // Default case is required.
break;
}
enum Colors { yellow, blue, brown, green }
immutable c = Colors.blue;
// "final switch" is safer, for enums (and in future other values,
// like Algebraic), because all cases must be present.
// with() is handy to avoid repeating "Colors." for each case.
final switch (c) with (Colors) {
case yellow: break;
case blue: break;
case brown, green: break;
// case yellow: .. case brown: // Forbidden in final switches.
// default: // Forbidden in final switches.
}
}</lang>
Dao
If Elif Else
<lang java>a = 3 if( a == 1 ){
io.writeln( 'a == 1' )
}else if( a== 3 ){
io.writeln( 'a == 3' )
}else{
io.writeln( 'a is neither 1 nor 3' )
}</lang>
Switch Case
<lang java>a = 3 switch( a ){ case 0: io.writeln( 'case 0' ) case 1, 2: io.writeln( 'case 1,2' ) case 3, 4, 5: io.writeln( 'case 3,4,5' ) default: io.writeln( 'default' ) }</lang>
Déjà Vu
<lang dejavu>if a:
pass
elseif b:
pass
else: # c, maybe?
pass</lang>
Deluge
<lang deluge>if (input.Field == "Hello World") {
sVar = "good";
} else if (input.Field == "Bye World") {
sVar = "bad";
} else {
sVar = "neutral";
}</lang>
Delphi
- See Pascal
DWScript
- See Pascal
E
if-then-else
<lang e>if (okay) {
println("okay")
} else if (!okay) {
println("not okay")
} else {
println("not my day")
}</lang>
The pick/2 message of booleans provides a value-based conditional:
<lang e>println(okay.pick("okay", "not okay"))</lang>
It can therefore be used to construct a Smalltalk-style conditional:
<lang e>okay.pick(fn {
println("okay")
}, fn {
println("not okay")
})()</lang>
All of the above conditionals are expressions and have a usable return value.
switch
E's "switch" allows pattern matching.
<lang e>def expression := ["+", [1, 2]]
def value := switch (expression) {
match [`+`, [a, b]] { a + b }
match [`*`, [a, b]] { a * b }
match [op, _] { throw(`unknown operator: $op`) }
}</lang>
Efene
The expressions can contain parenthesis or not, here both options are shown. Since if and case do pattern matching, if an if or case expression don't match some of the patterns, the program will crash
<lang efene> show_if_with_parenthesis = fn (Num) {
if (Num == 1) {
io.format("is one~n")
}
else if (Num === 2) {
io.format("is two~n")
}
else {
io.format("not one not two~n")
}
}
show_if_without_parenthesis = fn (Num) {
if Num == 1 {
io.format("is one~n")
}
else if Num === 2 {
io.format("is two~n")
}
else {
io.format("not one not two~n")
}
}
show_switch_with_parenthesis = fn (Num) {
switch (Num) {
case (1) {
io.format("one!~n")
}
case (2) {
io.format("two!~n")
}
else {
io.format("else~n")
}
}
}
show_switch_without_parenthesis = fn (Num) {
switch (Num) {
case 1 {
io.format("one!~n")
}
case 2 {
io.format("two!~n")
}
else {
io.format("else~n")
}
}
}
@public run = fn () {
show_if_with_parenthesis(random.uniform(3)) show_if_without_parenthesis(random.uniform(3))
show_switch_with_parenthesis(random.uniform(3)) show_switch_without_parenthesis(random.uniform(3))
}</lang>
Ela
if-then-else
<lang ela>if x < 0 then 0 else x</lang>
Guards
<lang ela>getX x | x < 0 = 0
| else = x</lang>
Pattern matching
<lang ela>force (x::xs) = x :: force xs force [] = []</lang>
match expression
<lang ela>force lst = match lst with
x::xs = x :: force xs
[] = []</lang>
Erlang
Erlang's conditionals are based on pattern matching and guards. There are several mechanisms for this: case-of, if, function clauses. Pattern matching allows destructuring a term and matches a clause based on the structure. In the case example the term is X and the pattern is {N,M} or _. _ will match anything, while {N,M} will only match tuples of two terms. Though N and M could be any other type (in this case an error will occur if they're non-numeric). Guards allow more specification on the terms from the matched pattern. In the case example comparing N and M are guards.
case
case expressions take an expression and match it to a pattern with optional guards.
<lang erlang>case X of
{N,M} when N > M -> M;
{N,M} when N < M -> N;
_ -> equal
end.</lang>
if
if expressions match against guards only, without pattern matching. Guards must evaluate to true or false so true is the catch-all clause.
<lang erlang>{N,M} = X, if
N > M -> M; N < M -> N; true -> equal
end.</lang>
Function Clauses
Functions can have multiple clauses tested in order.
<lang erlang>test({N,M}) when N > M -> M; test({N,M}) when N < M -> N; test(_) -> equal.</lang>
Factor
There are many conditional structures in Factor. Here I'll demonstrate the most common ones. A few of these have other variations that abstract common stack shuffle patterns. I will not be demonstrating them.
?
? is for when you don't need branching, but only need to select between two different values. <lang factor> t 1 2 ? ! returns 1 </lang>
if
<lang factor>t [ 1 ] [ 2 ] if ! returns 1</lang>
cond
<lang factor>{ { [ t ] [ 1 ] } { [ f ] [ 2 ] } } cond ! returns 1</lang>
case
<lang factor>t { { t [ 1 ] } { f [ 2 ] } } case ! returns 1</lang>
when
<lang factor>t [ "1" print ] when ! prints 1</lang>
unless
<lang factor>f [ "1" print ] unless ! prints 1</lang>
FALSE
<lang false>condition[body]?</lang> Because there is no "else", you need to stash the condition if you want the same effect: <lang false>$[\true\]?~[false]?</lang> or <lang false>$[%true0~]?~[false]?</lang>
Fancy
Fancy has no built-in conditional structures. It uses a combination of polymorphism and blockliterals (closures) to achieve the same thing (like Smalltalk).
if:then:
<lang fancy>if: (x < y) then: {
"x < y!" println # will only execute this block if x < y
} </lang>
if:then:else::
<lang fancy>if: (x < y) then: {
"x < y!" println # will only execute this block if x < y
} else: {
"x not < y!" println
} </lang>
if_true:
<lang fancy>x < y if_true: {
"x < y!" println # will only execute this block if x < y
} </lang>
if_false: / if_nil:
<lang fancy>x < y if_false: {
"x not < y!" println # will only execute this block if x >= y
} </lang>
if_true:else:
<lang fancy>x < y if_true: {
"x < y!" println
} else: {
"x >= y!" println
} </lang>
if_false:else:
<lang fancy>x < y if_false: {
"x >= y!"
} else: {
"x < y!" println
} </lang>
if:
<lang fancy>{ "x < y!" println } if: (x < y) # analog, but postfix</lang>
unless:
<lang fancy>{ "x not < y!" } unless: (x < y) # same here</lang>
Forth
IF-ELSE
<lang forth>( condition ) IF ( true statements ) THEN ( condition ) IF ( true statements ) ELSE ( false statements ) THEN</lang> example: <lang forth>10 < IF ." Less than 10" ELSE ." Greater than or equal to 10" THEN</lang>
CASE-OF
<lang forth>( n -- ) CASE ( integer ) OF ( statements ) ENDOF ( integer ) OF ( statements ) ENDOF ( default instructions ) ENDCASE</lang> example: a simple CASE selection <lang forth>: test-case ( n -- )
CASE
0 OF ." Zero!" ENDOF
1 OF ." One!" ENDOF
." Some other number!"
ENDCASE ;</lang>
Execution vector
To obtain the efficiency of a C switch statement for enumerations, one needs to construct one's own execution vector. <lang forth>: switch
CREATE ( default-xt [count-xts] count -- ) DUP , 0 DO , LOOP , DOES> ( u -- ) TUCK @ MIN 1+ CELLS + @ EXECUTE ;
:NONAME ." Out of range!" ; :NONAME ." nine" ; :NONAME ." eight" ; :NONAME ." seven" ; :NONAME ." six" ; :NONAME ." five" ; :NONAME ." four" ; :NONAME ." three" ; :NONAME ." two" ; :NONAME ." one" ; :NONAME ." zero" ;
10 switch digit
8 digit \ eight
34 digit \ Out of range!</lang>
Fortran
In ISO Fortran 90 and later, there are three conditional structures. There are also a number of other *unstructured* conditional statements, all of which are old and many of which are marked as "deprecated" in modern Fortran standards. These examples will, as requested, only cover conditional *structures*:
IF-THEN-ELSE
ANSI FORTRAN 77 or later has an IF-THEN-ELSE structure: <lang fortran>if ( a .gt. 20.0 ) then
q = q + a**2
else if ( a .ge. 0.0 ) then
q = q + 2*a**3
else
q = q - a
end if</lang>
SELECT-CASE
ISO Fortran 90 or later has a SELECT-CASE structure: <lang fortran>select case (i)
case (21:) ! matches all integers greater than 20
q = q + i**2
case (0:20) ! matches all integers between 0 and 20 (inclusive)
q = q + 2*i**3
case default ! matches all other integers (negative in this particular case)
q = q - I
end select</lang>
WHERE-ELSEWHERE
ISO Fortran 90 and later has a concurrent, array-expression-based WHERE-ELSEWHERE structure. The logical expressions in WHERE and ELSEWHERE clauses must be array-values. All statements inside the structure blocks must be array-valued. Furthermore, all array-valued expressions and statements must have the same "shape". That is, they must have the same number of dimensions, and each expression/statement must have the same sizes in corresponding dimensions as each other expression/statement. For each block, wherever the logical expression is true, the corresponding elements of the array expressions/statements are evaluated/executed. <lang fortran>! diffusion grid time step where (edge_type(1:n,1:m) == center)
anew(1:n,1:m) = (a(1:n,1:m) + a(0:n-1,1:m) + a(2:n+1,1:m) + a(1:n,0:m-1) + a(1:n,2:m+1)) / 5
elsewhere (edge_type(1:n,1:m) == left)
anew(1:n,1:m) = (a(1:n,1:m) + 2*a(2:n+1,1:m) + a(1:n,0:m-1) + a(1:n,2:m+1)) / 5
elsewhere (edge_type(1:n,1:m) == right)
anew(1:n,1:m) = (a(1:n,1:m) + 2*a(0:n-1,1:m) + a(1:n,0:m-1) + a(1:n,2:m+1)) / 5
elsewhere (edge_type(1:n,1:m) == top)
anew(1:n,1:m) = (a(1:n,1:m) + a(0:n-1,1:m) + a(2:n+1,1:m) + 2*a(1:n,2:m+1)) / 5
elsewhere (edge_type(1:n,1:m) == bottom)
anew(1:n,1:m) = (a(1:n,1:m) + a(0:n-1,1:m) + a(2:n+1,1:m) + 2*a(1:n,0:m-1)) / 5
elsewhere (edge_type(1:n,1:m) == left_top)
anew(1:n,1:m) = (a(1:n,1:m) + 2*a(2:n+1,1:m) + 2*a(1:n,2:m+1)) / 5
elsewhere (edge_type(1:n,1:m) == right_top)
anew(1:n,1:m) = (a(1:n,1:m) + 2*a(0:n-1,1:m) + 2*a(1:n,2:m+1)) / 5
elsewhere (edge_type(1:n,1:m) == left_bottom)
anew(1:n,1:m) = (a(1:n,1:m) + 2*a(2:n+1,1:m) + 2*a(1:n,0:m-1)) / 5
elsewhere (edge_type(1:n,1:m) == right_bottom)
anew(1:n,1:m) = (a(1:n,1:m) + 2*a(0:n-1,1:m) + 2*a(1:n,0:m-1)) / 5
elsewhere ! sink/source, does not change
anew(1:n,1:m) = a(1:n,1:m)
end where</lang>
friendly interactive shell
if-then-else
<lang fishshell>set var 'Hello World' if test $var = 'Hello World'
echo 'Welcome.'
else if test $var = 'Bye World'
echo 'Bye.'
else
echo 'Huh?'
end</lang>
switch
case statements take wildcards as arguments, but because of syntax quirk, they have to be quoted (just like in Powershell), otherwise they would match files in current directory. Unlike switch statements in C, they don't fall through. To match something that would be matched if nothing was matches use wildcard that matches everything, the language doesn't have default statement. <lang fishshell>switch actually
case az
echo The word is "az".
case 'a*z'
echo Begins with a and ends with z.
case 'a*'
echo Begins with a.
case 'z*'
echo Ends with z.
case '*'
echo Neither begins with a or ends with z.
end</lang>
GAP
if-then-else
<lang gap>if <condition> then
<statements>
elif <condition> then
<statements>
else
<statements>
fi;</lang>
Go
If and switch are the general purpose conditional structures in Go, although the language certainly contains other conditional elements.
If
Simplest usage is, <lang go>if booleanExpression {
statements
}</lang> The braces are required, even around a single statement. <lang go>if booleanExpression {
statements
} else {
other statements
}</lang> Braces are required around else clauses, as above, unless the statement of the else clause is another if statement. In this case the statements are chained like this, <lang go>if booleanExpression1 {
statements
} else if booleanExpression2 {
otherStatements
} </lang> If allows a statement to be included ahead of the condition. This is commonly a short variable declaration, as in, <lang go>if x := fetchSomething(); if x > 0 {
DoPos(x)
} else {
DoNeg(x)
}</lang> In this case the scope of x is limited to if statement.
Switch
Simple usage is, <lang go>switch { case booleanExpression1:
statements
case booleanExpression2:
other statements
default:
last resort statements
}</lang> Because switch can work with any number of arbitrary boolean expressions, it replaces if/elseif chains often found in other programming languages.
Switch can also switch on the value of an expression, as in, <lang go>switch expressionOfAnyType { case value1:
statements
case value2, value3, value4:
other statements
}</lang> As shown, multiple values can be listed for a single case clause. Since go is statically typed, the types of value1, 2, 3, and 4 must match the type of the expression.
As with if, a local statement such as a short variable declaration can precede the expression. If there is no expression, the statement is still marked by a semicolon: <lang go>switch x := fetch(); { case x == "cheese":
statements
case otherBooleanExpression:
other statements
}</lang> Also, as with if, the scope of x is limited to the switch statement.
Execution does not normally fall through from one case clause to the next, but this behavior can be forced with a fallthrough statement.
An interesting example: <lang go>switch { case booleanExpression1: default:
statements preliminaryToOtherStatements fallthrough
case booleanExpression2:
other statements
}</lang> Case expressions are evaluated in order, then if none are true, the default clause is executed.
Another statement that interacts with switch is break. It breaks from the switch statement and so will not break from a surrounding for statement. The following example prints "I want out!" endlessly. <lang go>for {
switch {
case true:
break
}
fmt.Println("I want out!")
}</lang> Labels provide the desired capability. The following prints "I'm off!" <lang go>treadmill: for {
switch {
case true:
break treadmill
}
} fmt.Println("I'm off!")</lang>
Harbour
if-elseif-else-endif <lang visualfoxpro>IF x == 1
SomeFunc1()
ELSEIF x == 2
SomeFunc2()
ELSE
SomeFunc()
ENDIF</lang>
do case <lang visualfoxpro>DO CASE CASE x == 1
SomeFunc1()
CASE x == 2
SomeFunc2()
OTHERWISE
SomeFunc()
ENDCASE</lang>
switch While if-elseif-else-endif and do case constructions allows using of any expressions as conditions, the switch allows literals only in conditional case statements. The advantage of the switch command is that it is much faster. <lang visualfoxpro>SWITCH x CASE 1
SomeFunc1() EXIT
CASE 2
SomeFunc2() EXIT
OTHERWISE
SomeFunc()
ENDSWITCH</lang>
Haskell
if-then-else
<lang haskell>fac x = if x==0 then
1
else x * fac (x - 1)</lang>
Guards
<lang haskell>fac x | x==0 = 1
| x>0 = x * fac (x-1)</lang>
Pattern matching
<lang haskell>fac 0 = 1 fac x = x * fac (x-1)</lang>
case statement
<lang haskell>fac x = case x of 0 -> 1
_ -> x * fac (x-1)</lang>
HicEst
<lang hicest>IF( a > 5 ) WRITE(Messagebox) a ! single line IF
IF( a >= b ) THEN
WRITE(Text=some_string) a, b ELSEIF(some_string > "?") THEN WRITE(ClipBoard) some_string ELSEIF( nonzero ) THEN WRITE(WINdowhandle=nnn) some_string ELSE WRITE(StatusBar) a, b, some_string
ENDIF</lang>
IDL
if-else
Basic if/then:
<lang idl>if a eq 5 then print, "a equals five" [else print, "a is something else"]</lang>
Any one statement (like these print statements) can always be expanded into a {begin ... end} pair with any amount of code in between. Thus the above will expand like this:
<lang idl>if a eq 5 then begin
... some code here ...
endif [else begin
... some other code here ...
endelse]</lang>
case
<lang idl>case <expression> of
(choice-1): <command-1> [(choice-2): <command-2> [...]] [else: <command-else>]
endcase</lang>
(Or replace any of the commands with {begin..end} pairs)
switch
<lang idl>switch <expression> of
(choice-1): <command-1> [(choice-2): <command-2> [...]] [else: <command-else>]
endswitch</lang>
The switch will execute all commands starting with the matching result, while the case will only execute the matching one.
on_error
<lang idl>on_error label</lang>
Will resume execution at label when an error is encountered. on_ioerror is similar but for IO errors.
Icon and Unicon
All Icon and Unicon expressions, including control structures, yield results or signal failure.
if-then-else
The control structure evaluates expr1 if expr0 succeeds and expr2 if it fails. <lang Icon>if expr0 then
expr1
else
expr2</lang>
case-of
The first successful selection expression will select and evaluate the specific case. <lang Icon>case expr0 of {
expr1 : expr2 expr3 : expr4 default: expr5 }</lang>
Note that expr1 and expr3 are expressions and not constants and it is possible to write expressions such as: <lang Icon>case x of {
f(x) | g(x) : expr2 s(x) & t(x) : expr4 default: expr5 }</lang>
Compound expressions (blocks)
In the examples below, multiple expressions can be grouped as in: <lang Icon>{
expr1 expr2 expr3
}</lang> Which is equivalent to this: <lang Icon>{expr1; expr2; expr3}</lang> For example the following, which will write 4, looks strange but is valid: <lang Icon>write({1;2;3;4})</lang> The value of a compound expression is the value of the last expression in the block.
Alternation
Alternation of expressions yields a value for the first succeeding expression. <lang Icon> expr1 | expr2 | expr3</lang>
Conjunction
Conjunctions yeild the value of the final expression provided all the previous expressions succeed. <lang Icon> expr1 & expr2 & expr3</lang> Alternately, conjunction can be written thus: <lang Icon> (expr1, expr2, expr3)</lang>
Conjunction, yielding a different result
The alternate form of conjunction can be modified to produce a different result (other than the last)
<lang Icon> expr0(expr1, expr2, expr3)</lang>
For example:
<lang Icon> 2(expr1, expr2, expr3)</lang>
Yields the value of expr2 if all of the expressions succeed.
A more complicated example showing non-constant expressions:
<lang Icon> f(expr1)(g(expr2)(expr3,expr4,expr5))</lang>
Note: if expr0 yields a value of type 'procedure' or 'string' the appropriate procedure (or operator) is invoked.
Inform 7
if-then-else
<lang inform7>[short form] if N is 1, say "one."; otherwise say "not one.";
[block form] if N is 1: say "one."; otherwise if N is 2: say "two."; otherwise: say "not one or two.";
[short and long forms can be negated with "unless"] unless N is 1, say "not one."</lang>
switch
<lang inform7>if N is: -- 1: say "one."; -- 2: say "two."; -- otherwise: say "not one or two.";</lang>
if-then-else in text
<lang inform7>say "[if N is 1]one[otherwise if N is 2]two[otherwise]three[end if]."; say "[unless N is odd]even.[end if]";</lang>
other branching text substitutions
Text that may be printed multiple times can also use sequential and random branching: <lang inform7>[a different color every time] say "[one of]red[or]blue[or]green[at random].";
["one" the first time it's printed, "two" the second time, then "three or more" subsequently] say "[one of]one[or]two[or]three or more[stopping]";
[only appears once] say "[first time]Hello world![only]";</lang>
rulebook approach
Conditional logic may also be expressed in the form of a rulebook, with conditions on each rule:
<lang inform7>Number Factory is a room.
Number handling is a number based rulebook with default success.
Number handling for 1: say "one." Number handling for 2: say "two." Number handling for an even number (called N): say "[N in words] (which is even)." Last number handling rule: say "other."
When play begins: follow the number handling rules for 2; follow the number handling rules for 4; follow the number handling rules for 5.</lang>
J
Java
if-then-else
<lang java>if(s.equals("Hello World")) {
foo();
} else if(s.equals("Bye World"))
bar();//{}'s optional for one-liners
else {
deusEx();
}</lang> Java also supports short-circuit evaluation. So in a conditional like this: <lang java>if(obj != null && obj.foo()){
aMethod();
}</lang> obj.foo() will not be executed if obj != null returns false. It is possible to have conditionals without short circuit evaluation using the & and | operators (from Bitwise operations). So in this conditional: <lang java>if(obj != null & obj.foo()){
aMethod();
}</lang> You will get a null pointer exception if obj is null.
ternary
<lang java>s.equals("Hello World") ? foo() : bar();</lang>
switch
This structure will only work if the code being switched on evaluates to an integer or character. There is no switching on Objects or floating-point types in Java (except for Strings in Java 7 and higher).
<lang java>switch(c) {
case 'a':
foo(); break;
case 'b':
bar();
default:
foobar();
}</lang> This particular example can show the "fallthrough" behavior of a switch statement. If c is the character b, then bar() and foobar() will both be called. If c is the character a, only foo() will be called because of the break statement at the end of that case.
Also, the switch statement can be easily translated into an if-else if-else statement. The example above is equivalent to: <lang java>if(c == 'a'){
foo();
}else if(c == 'b'){
bar(); foobar();
}else{
foobar();
}</lang> Cases without breaks at the end require duplication of code for all cases underneath them until a break is found (like the else if block shown here).
JavaScript
if-then-else
<lang javascript>if( s == "Hello World" ) {
foo();
} else if( s == "Bye World" ) {
bar();
} else {
deusEx();
}</lang>
switch
<lang javascript>switch(object) {
case 1:
one();
break;
case 2:
case 3:
case 4:
twoThreeOrFour();
break;
case 5:
five();
break;
default:
everythingElse();
}</lang>
conditional (ternary) operator (?:)
<lang javascript>var num = window.obj ? obj.getNumber() : null;</lang>
The distinctive feature of the ternary operator (compared to JavaScript's other conditional structures) is that it evaluates as an expression rather than a statement, and can therefore be composed within larger expressions, making it a valuable resource of program structure in a functional idiom of JavaScript.
<lang JavaScript>function takeWhile(lst, fnTest) {
'use strict'; var varHead = lst.length ? lst[0] : null;
return varHead ? (
fnTest(varHead) ? [varHead].concat(
takeWhile(lst.slice(1), fnTest)
) : []
) : [];
}</lang>
jq
jq's main conditional construct is:<lang jq>if cond then f else g end</lang>where cond, f, and g, are filters, and where cond may evaluate to anything at all, it being understood that:
- all JSON values are truthy except for false and null;
- if cond evaluates to nothing (i.e., produces an empty stream), then the entire if-then-else-end expression also produces an empty stream.
The general pattern allows one or more "elif _ then _" clauses: <lang jq> if cond then f elif cond1 then f1 .... else g end </lang>
For example:<lang jq> if empty then 2 else 3 end # produces no value if 1 then 2 else 3 end # produces 2 if [false, false] then 2 else 3 end # produces 2 if (true, true) then 2 else 3 end # produces a stream: 2, 2 </lang>Notice that if cond produces a nonempty stream, then the entire expression will typically do the same. Since f and g also can produce streams, this lends itself to interesting Cartesian-product possibilities.
There is no "case <exp>" construct, but the idiom illustrated by the following example can be used to avoid the need to create a temporary variable to hold the "case" expression:<lang jq> exp
| if . == true then "true"
elif . == false then "false"
elif . == null then "maybe"
elif type == "string" then .
else error("unexpected value: \(.)")
end</lang>
Since jq's and and or are short-circuiting, they can also be used for branching.
LabVIEW
Case Structure
This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.
Select
Select is similar to the Ternary operator in text-based languages.
LC3 Assembly
The LC3 sets condition codes (N[egative], Z[ero], and/or P[ositive]) based on the results of instructions that write values into the general purpose registers. The BR instruction utilizes these condition codes are to branch conditionally. If the BR instruction specifies one or more condition codes and at least one specified code is set, then the PC will be updated to the branch address. If none of the specified condition codes is set, then the next sequential instruction will execute. If the BR instruction does not specify any condition codes, then it is an unconditional branch, so the branch will be taken. <lang lc3asm>BR or BRnzp ; unconditional branch, i.e.
; branch if (result < 0 || result == 0 || result > 0)
; ^ this is always true
BRn ; branch if (result < 0) BRz ; branch if (result == 0) BRp ; branch if (result > 0)
; or any combination of these condition codes, e.g.
BRnz ; branch if (result <= 0)</lang> The effect of if (x == y) { go to LABEL } is achieved by adding x to -y (the two's complements of y) and branching if the result is zero. The following example prints "Branch Taken!" because the values of x and y are both 1. <lang lc3asm>.orig x3000 LD R1, x ; get x LD R2, y ; get y NOT R0, R2 ; R0 = ~y ADD R0, R0, 1 ; R0 = -y ADD R0, R0, R1 ; R0 = x - y BRZ BRANCH ; if (x == y) { go to BRANCH } LEA R0, nottaken PUTS ; else print "Branch Not Taken!" BR END BRANCH LEA R0, taken PUTS ; print "Branch Taken!" END HALT x .fill 1 y .fill 1 taken .stringz "Branch Taken!" nottaken .stringz "Branch Not Taken!" .end</lang>
Lisaac
if-then-else
<lang Lisaac>+ n : INTEGER;
n := 3;
(n = 2).if {
IO.put_string "n is 2\n";
}.elseif {n = 3} then {
IO.put_string "n is 3\n";
}.elseif {n = 4} then {
IO.put_string "n is 4\n";
} else {
IO.put_string "n is none of the above\n";
};</lang> <lang Lisaac>(n = 2).if_true { "n is 2\n".print; }; (n = 2).if_false { "n is not 2\n".print; };</lang>
when
<lang Lisaac>+ n : INTEGER;
n := 3; n .when 2 then {
"n is 2\n".print;
} .when 3 then {
"n is 3\n".print;
} .when 4 then {
"n is 4\n".print;
};</lang> There is no "else" or "otherwise" method. If the values of the when-methods are overlapped, the related blocks will be evaluated ... they are not mutually exclusive.
Little
<lang C>int a = 3;
// if-then-else if (a == 2) {
puts ("a is 2");
} else if (a == 3) {
puts ("a is 3");
} else {
puts("a is 4");
}
// unless unless (a == 2) { // equivalent to if (a != 2)
puts ("a is 2"); // It will print this line
} else if (a == 3) {
puts ("a is 3");
} else {
puts("a is 4");
}
// switch switch (a) {
case 2:
puts ("a is 2");
break;
case 3:
puts ("a is 3");
break;
case 4:
puts ("a is 4");
break;
default:
puts("is neither");
}</lang>
Logo
<lang logo>if :x < 0 [make "x 0 - :x]
ifelse emptyp :list [print [empty]] [print :list]</lang> UCB Logo and its descendants have also case: <lang logo>to vowel? :letter output case :letter [ [[a e i o u] "true] [else "false] ] end show vowel? "e show vowel? "x</lang>
- Output:
<lang logo>true false</lang> Logo also provides TEST which is local to a procedure: <lang logo>to mytest :arg1 :arg2 test :arg1 = :arg2 iftrue [print [Arguments are equal]] iffalse [print [Arguments are not equal]] end</lang>
LSE64
The simple conditionals take single words rather than blocks of statements, as in most other languages. <lang lse64>t : " true" ,t f : " false" ,t true if t false ifnot f true ifelse t f</lang>
Cascading conditionals are constructed using duplicate definitions and "then", yielding a syntax reminiscent of functional language Pattern Matching. <lang lse64>onetwo : drop " Neither one nor two" ,t # default declared first onetwo : dup 2 = then " Two" ,t onetwo : dup 1 = then " One" ,t</lang>
Short-circuit operators "&&" and "||" are used for complex conditionals. <lang lse64>dup 0 = || ,t # avoid printing a null string</lang>
Lua
<lang Lua> --if-then-elseif-then-else if a then
b()
elseif c then
d()
else
e()
end
for var = start, _end, step do --note: end is a reserved word
something()
end
for var, var2, etc in iteratorfunction do
something()
end
while somethingistrue() do
something()
end
repeat
something()
until somethingistrue()
cases = { key1 = dothis, key2 = dothat, key3 = dotheother }
cases[key]() --equivalent to dothis(), dothat(), or dotheother() respectively</lang>
Make
An if condition using pure make (no gmake extensions) <lang make># make -f do.mk C=mycond if C=0
if:
-@expr $(C) >/dev/null && make -f do.mk true; exit 0 -@expr $(C) >/dev/null || make -f do.mk false; exit 0
true:
@echo "was true."
false:
@echo "was false."</lang>
Using it <lang make>make -f do.mk if C=0 > was false.
make -f do.mk if C=1 > was true.</lang>
With out using recursion but letting make continue with non-failed targets even when some of the targets failed (-k) <lang make>C=0
if: true false
true:
@expr $(C) >/dev/null && exit 0 || exit 1 @echo "was true."
false:
@expr $(C) >/dev/null && exit 1 || exit 0 @echo "was false."</lang>
Invoking it. Note the use of -k which allows make to evaluate subsequent targets even when a previous non-related target failed. <lang make>|make -f do.mk -s -k C=1 was true.
- Error code 1
|make -f do.mk -s -k C=0
- Error code 1
was false.</lang>
Using gmake
<lang make>A= B=
ifeq "$(A)" "1"
B=true
else
B=false
endif
do:
@echo $(A) .. $(B)</lang>
Using it <lang make>|gmake -f if.mk A=1 1 .. true |gmake -f if.mk A=0 0 .. false</lang>
Maple
Maple offers both conditional statements and conditional functions.
Conditional statements
Example syntax for conditional statements: <lang Maple>if x > 0 then
res := x;
else
res := -x;
end if;</lang>
Example syntax for conditional statements with else-if: <lang Maple>if x = 0 then
res := y;
elif y = 0 then
res := x;
else
res := sqrt(x^2+y^2);
end if;</lang>
Conditional functions
The Maple function `if`(cond,a,b) (note the backtick ` delimiters) returns a when cond is true and b otherwise.
res := `if`(n::even, n/2, 3*n+1);
The piecewise command can be used for functional evaluation in which there is more than one branch. The following is equivalent to the if/then construct from the previous section.
res := piecewise(x=0, y, y=0, x, sqrt(x^2+y^2));
Mathematica
Usual If[condition,True,False]
Make a definition with the condition that x should be positive:
f[x_] := ppp[x] /; x > 0
f[5] gives ppp[5]
f[-6] gives f[-6]
MATLAB
If statements
Example: <lang MATLAB>if x == 1
disp 'x==1';
elseif x > 1
disp 'x>1';
else
disp 'x<1';
end</lang>
Switch statements
Example: <lang MATLAB>switch x
case 1
disp 'Hello';
case 2
disp 'World';
otherwise
disp 'Skynet Active';
end</lang>
Maxima
<lang maxima>if test1 then (...) elseif test2 then (...) else (...);</lang>
MAXScript
if
<lang maxscript>if x == 1 then (
print "one"
) else if x == 2 then (
print "two"
) else (
print "Neither one or two"
)</lang>
case
Form one <lang maxscript>case x of (
1: (print "one") 2: (print "two") default: (print "Neither one or two")
)</lang> Form two <lang maxscript>case of (
(x == 1): (print "one") (x == 2): (print "two") default: (print "Neither one or two")
)</lang>
MBS
<lang MBS>INT x; x:=0; IF x = 1 THEN
! Do something
ELSE
! Do something else
ENDIF;</lang>
Metafont
<lang metafont>if conditionA:
% do something
elseif conditionB:
% do something
% more elseif, if needed... else:
% do this
fi;</lang>
The particularity of if construct in Metafont is that it can be part of an expression, and the "do something" does not need to fit into the syntactic structure. E.g. we can write something like
<lang metafont>b := if a > 5: 3 + else: 2 - fi c;</lang>
Alone, the code 3 + does not mean anything; but once the condition is evaluated, the whole expression must become "correct"; e.g. if a > 5, the expression will be b := 3 + c;.
There are no other kind of conditional structures, but the great flexibility of Metafont allows for sure to create "new syntaxes" similar to switches or whatever needed.
МК-61/52
Conditional jumps are done by four instructions, comparing the register X with zero:
<lang>x=0 XX x#0 XX x>=0 XX x<0 XX</lang>
XX here is the address to which to make the jump in the event of failure of this condition (for this reason, these instructions are also called checks).
Modula-2
if-then-else
<lang modula2>IF i = 1 THEN
InOut.WriteString('One')
ELSIF i = 2 THEN
InOut.WriteString('Two')
ELSIF i = 3 THEN
InOut.WriteString('Three')
ELSE
InOut.WriteString('Other')
END;</lang>
Case
<lang modula2>CASE i OF
1 : InOut.WriteString('One')
| 2 : InOut.WriteString('Two') | 3 : InOut.WriteString('Three') ELSE
InOut.WriteString('Other')
END</lang>
Modula-3
if-then-else
<lang modula3>IF Foo = TRUE THEN
Bar();
ELSE
Baz();
END;</lang>
<lang modula3>IF Foo = "foo" THEN
Bar();
ELSIF Foo = "bar" THEN
Baz();
ELSIF Foo = "foobar" THEN
Quux();
ELSE
Zeepf();
END;</lang>
Case
<lang modula3>CASE Foo OF | 1 => IO.Put("One\n"); | 2 => IO.Put("Two\n"); | 3 => IO.Put("Three\n"); ELSE
IO.Put("Something\n");
END;</lang>
Type-case
TYPECASE is used on reference types to perform different operations, depending on what it is a reference to. <lang modula3>TYPECASE ref OF | NULL => IO.Put("Null\n"); | CHAR => IO.Put("Char\n"); | INTEGER => IO.Put("Integer\n"); ELSE
IO.Put("Something\n");
END;</lang>
Monicelli
Monicelli has a single conditional structure that covers both if/then/else and switch/case <lang monicelli> che cosè var? # switch var
minore di 0: # case var < 0
...
maggiore di 0: # case var > 0
...
o tarapia tapioco: # else (none of the previous cases)
...
e velocità di esecuzione </lang>
Morfa
if-then-else
<lang morfa> if(s == "Hello World") {
foo();
} else if(s == "Bye World")
bar();
else {
baz();
} </lang> Morfa supports short-circuit evaluation, so obj.foo() won't be executed if obj is null: <lang morfa> if(obj isnt null and obj.foo())
doSomething();
</lang>
ternary
<lang morfa> var t = if(s == "Hello World") foo() else bar(); </lang>
switch
There is no fallthrough, break statement does not have any special meaning inside a switch. If the break is in a loop then break exits that loop, otherwise it is invalid. <lang morfa> switch (num)
{
case (0)
{ /* empty case requires braces */ }
case (1)
{ var one = "one"; result = one; }
case (2,3) // case may contain a nonempty list of values
result = "a few";
default
result = "a lot";
}
</lang>
MUMPS
If / I and ELSE / E
<lang MUMPS> IF A list-of-MUMPS-commands</lang>
All standard versions of MUMPS allow a ELSE command, which can be abbreviated to E. Instead of depending on the previous IF command, the ELSE command depends on the value of the system variable $TEST. $TEST is set whenever an IF command is executed, and whenever a timeout is specified. Since $TEST could be changed and not noticed by an unwary programmer it is important to remember when writing code. For example with the code: <lang MUMPS> IF T DO SUBROUTINE ELSE DO SOMETHING</lang> It isn't clear whether $TEST is changed or not, because the function SUBROUTINE might change the value of $TEST by using a timeout or an IF command. It is better to explicitly set the $TEST special variable using IF 1 for example: <lang MUMPS> IF T DO SUBROUTINE IF 1 ELSE DO SOMETHING</lang> Another common practice is to use the argumentless DO, as it pushes the $TEST variable onto a stack and replaces it after the "dot block" is complete. An example of this code is: <lang MUMPS> IF T DO . DO SUBROUTINE ELSE DO SOMETHING</lang>
$Select / $S
<lang MUMPS> WRITE $SELECT(1=2:"Unequal",1=3:"More unequal",1:"Who cares?")</lang>
The $Select statement contains couplets separated by commas, which each consist of a conditional test, followed by a colon, and what to return if that condition is true. The first part of the couplet must be a truth value. Since only zero is interpreted a truth value of false, any nonzero numbers when interpreted as a truth value will be considered to be true. Typically the number 1 is used as an explicitly true condition and is placed in the final couplet. If no conditions are true, the program's error processing is invoked. The very first condition that is true is the result of the expression. In the example, the value will always be "Unequal" as it is always true, and the rest of the $SELECT will never be used.
(command postconditional i.e. colon/:
<lang MUMPS> SET:(1=1) SKY="Blue"
GOTO:ReallyGo LABEL QUIT:LoopDone WRITE:NotLastInSet ","</lang>
Most commands can take a "postconditional", which is a colon and some conditional statement immediately after the command followed by the command separator (space) and the usual arguments of the command. The command is executed only if the conditional statement evaluates to true.
The exceptions are FOR, IF, and ELSE. There are several commands that also allow for post-conditionals in their arguments. The GOTO, and DO commands must have a label but it optionally have a colon followed by a truth value. When the truth value is interpreted as false, the flow of control does NOT move to the label indicated. If it is true, then flow of control does move to the label. Similarly, the XECUTE command may have a colon and postcondition on its argument, which is a expression that is interpreted as a line of MUMPS code. That code is executed when the postcondition is true, and not executed when it is false. Some people consider timeouts to be a form of conditional. For example in the READ command, a number (or numeric expression) after a colon is the number of seconds to wait for a user to make an entry. If the user doesn't make an entry before the timeout, the special variable $TEST is set to 0 (zero), indicating a timeout has occurred. Likewise in the JOB command, a number (or numeric expression) after a colon is the number of seconds to wait for the system to start a new job running in "parallel" to the current job. If the system does not create a new job before the timeout, the special variable $TEST is set to 0 (zero), indicating a timeout has occurred.
Nemerle
if-else
if (cond) <then> else <this>; is an expression in Nemerle, requiring both keywords (if and else) to be valid. when and unless are macros for which <this> = null. cond must be an expression that evaluates to a bool (true|false), other types aren't automatically assigned truth or falsehood as in some languages. <lang Nemerle>if (the_answer == 42) FindQuestion() else Foo(); when (stock.price < buy_order) stock.Buy(); unless (text < "") Write(text);</lang>
match
Much cleaner than stacked if-else's, similar in some ways to switch-case (but more flexible). See here, here, or, for extra detail, the reference. <lang Nemerle>match(x) {
|1 => "x is one" |x when (x < 5) => "x is less than five" |_ => "x is at least five"
}</lang>
NetRexx
IF-THEN-ELSE
<lang NetRexx>-- simple construct if logicalCondition then conditionWasTrue()
else conditionWasFalse()
-- multi-line is ok too if logicalCondition then
conditionWasTrue()
else
conditionWasFalse()
-- using block stuctures if logicalCondition then do
conditionWasTrue() ... end
else do
conditionWasFalse() ... end
-- if/else if... if logicalCondition1 then do
condition1WasTrue() ... end
else if logicalCondition2 then do
condition2WasTrue() ... end
else do
conditionsWereFalse() ... end</lang>
SELECT
Notes: SELECT can be thought of as a better IF-THEN-ELSE construct.
Block structures (DO-END) can be used here too (see IF-THEN-ELSE).
OTHERWISE is optional but may result in run-time errors (netrexx.lang.NoOtherwiseException) if it isn't provided. <lang NetRexx>-- simple construct select
when logicalCondition1 then condition1() when logicalCondition2 then condition2() otherwise conditionDefault() end
-- set up a catch block to intercept missing OTHERWISE clause do
select when logicalCondition1 then condition1() when logicalCondition2 then condition2() end
catch ex1 = NoOtherwiseException
ex1.printStackTrace()
end</lang>
SELECT-CASE
<lang NetRexx>-- simple construct select case cc
when 'A' then say 'the case is A' when 'B' then say 'the case is B' otherwise say 'selection not recognized' end</lang>
Note: This is functionally equivalent to: <lang NetRexx>select
when cc == 'A' then ... when cc == 'B' then ... ...</lang>
SELECT Optional Features
SELECT has optional features (CATCH & FINALLY) and options (LABEL, PROTECT & CASE)
CATCH and FINALLY are used for handling exceptions thrown from inside the select group.
CASE see SELECT-CASE above.
LABEL provides a target for any LEAVE instructions and can aid in code self-documentation.
PROTECT is used for program concurrency & synchonization in multi-threaded programs. <lang NetRexx>select label sl protect cc case cc
when 'A' then do say 'the case is A' if logicalCondition then leave sl -- just to use the lable say '...' end when 'B' then do say 'the case is B' say '...' end otherwise say 'selection not recognized' say '...' catch exs = RuntimeException say 'Gronk!' exs.printStackTrace() finally say 'selection done' say 'TTFN' end sl</lang>
newLISP
if
Interpreter: newLISP v.9.0 <lang lisp>(set 'x 1) (if (= x 1) (println "is 1"))</lang> A third expression can be used as an else. <lang lisp>(set 'x 0) (if (= x 1) (println "is 1") (println "not 1"))</lang>
Nim
if-then-else
<lang nim>if x == 0:
foo()
elif x == 1:
bar()
elif x == 2:
baz()
else:
boz()</lang>
case-of
<lang nim>case x of 0:
foo()
of 2,5,9:
baz()
of 10..20, 40..50:
baz()
else: # All cases must be covered
boz()</lang>
Object Pascal
- See Pascal
Objective-C
- See also C
One difference: the preprocessor has been extended with an #import directive which does the same thing as #include with "include guards".
Objeck
if-else
<lang objeck> a := GetValue(); if(a < 5) {
"less than 5"->PrintLine();
} else if(a > 5) {
"greater than 5"->PrintLine();
} else {
"equal to 5"->PrintLine();
}; </lang>
select
<lang objeck> a := GetValue(); select(a) {
label 5: {
"equal to 5"->PrintLine();
}
label 7: {
"equal to 7"->PrintLine();
}
other: {
"another value"->PrintLine();
}
}; </lang>
OCaml
if-then-else
<lang ocaml>let condition = true
if condition then
1 (* evaluate something *)
else
2 (* evaluate something *)</lang>
If-then-else has higher precedence than ; (the semicolon), so if you want to have multiple statements with side effects inside an "if", you have to enclose it with begin...end or with parentheses:
<lang ocaml>if condition then begin
(); (* evaluate things for side effects *) 5
end else begin
(); (* evaluate things for side effects *) 42
end</lang>
match-with
<lang ocaml>match expression with | 0 -> () (* evaluate something *) | 1 -> () (* evaluate something *) | n when n mod 2 = 0 -> () (* evaluate something *) | _ -> () (* evaluate something *)</lang>
The first | is optional, and usually omitted.
Match is especially useful for Pattern Matching on various types of data structures.
Nested match's need to be surrounded by begin-end or parentheses, or else it won't know where it ends.
Octave
if-then-elseif-else <lang octave>if (condition)
% body
endif
if (condition)
% body
else
% otherwise body
endif
if (condition1)
% body
elseif (condition2)
% body 2
else
% otherwise body
endif</lang>
switch <lang octave>switch( expression )
case label1 % code for label1 case label2 % code for label2 otherwise % none of the previous
endswitch</lang>
Labels can be numeric or string, or cells to group several possibilities:
<lang octave>switch ( x )
case 1
disp("it is 1");
case { 5,6,7 }
disp("it is 5, or 6 or 7");
otherwise
disp("unknown!");
endswitch</lang>
Oforth
Conditional structures are :
<lang Oforth>aBoolean ifTrue: [ ...] aBoolean ifFalse: [ ... ] aObject ifNull: [ ... ] aObject ifNotNull: [ ... ] aObject ifZero: [ ... ]</lang>
Each conditional structure consume the object on the top of the stack.
Each conditional structure can be followed by a else block <lang Oforth>else: [ ... ]</lang>
Example :
<lang Oforth>Number virtual: sgn
self isPositive
ifTrue: [ self ==0 ifTrue: [ 0 ] else: [ 1 ] ]
else: [ -1 ] ;</lang>
ooRexx
For all of the conditional instructions, the conditional expression must evaluate either to '1' or '0'. Note that ooRexx conditional expression evaluation does not have a short circuiting mechanism. Where the logical operations | (or), & (and), or && (exclusive or) are used, all parts of the expression are evaluated. The conditional may also be a list of conditional expressions separated by commas. The expressions are evaluated left-to-right, and evaluation will stop with the first '0' result. For example, <lang ooRexx>if arg~isa(.string) & arg~left(1) == "*" then call processArg arg</lang>
would fail with a syntax error if the variable arg does not hold a string because the right-hand-side of the expression is still evaluated. This can be coded as
<lang ooRexx>if arg~isa(.string), arg~left(1) == "*" then call processArg arg</lang> With this form, the second conditional expression is only evaluated if the first expression is true.
IF THEN --- IF THEN/ELSE
<lang ooRexx> if y then x=6 /* Y must be either 0 or 1 */
if t**2>u then x=y
else x=-y
if t**2>u then do j=1 to 10; say prime(j); end
else x=-y
if z>w+4 then do
z=abs(z)
say 'z='z
end
else do; z=0; say 'failed.'; end
if x>y & c*d<sqrt(pz) |,
substr(abc,4,1)=='@' then if z=0 then call punt
else nop
else if z<0 then z=-y
</lang>
SELECT WHEN
<lang ooRexx>
/*the WHEN conditional operators are the same as */
/*the IF conditional operators. */
select
when t<0 then z=abs(u)
when t=0 & y=0 then z=0
when t>0 then do
y=sqrt(z)
z=u**2
end
/*if control reaches this point and none of the WHENs */
/*were satisfiied, a SYNTAX condition is raised (error).*/
end
</lang>
SELECT WHEN/OTHERWISE
<lang ooRexx>
select
when a=='angel' then many='host'
when a=='ass' | a=='donkey' then many='pace'
when a=='crocodile' then many='bask'
when a=='crow' then many='murder'
when a=='lark' then many='ascension'
when a=='quail' then many='bevy'
when a=='wolf' then many='pack'
otherwise say
say '*** error! ***'
say a "isn't one of the known thingys."
say
exit 13
end
</lang>
OxygenBasic
<lang oxygenbasic> if a then b=c else b=d
if a=0
b=c
elseif a<0
b=d
else
b=e
end if
select case a
case 'A' v=21
case 'B'
v=22
case 1 to 64
v=a+300
case else
v=0
end select
</lang>
Oz
if-then-else
<lang oz>proc {PrintParity X}
if {IsEven X} then
{Show even}
elseif {IsOdd X} then
{Show odd}
else
{Show 'should not happen'}
end
end</lang>
if-then-else as a ternary operator
<lang oz>fun {Max X Y}
if X > Y then X else Y end
end</lang>
case statement
<lang oz>fun {Fac X}
case X of 0 then 1
[] _ then X * {Fac X-1}
end
end</lang>
PARI/GP
GP uses a simple if statement:
<lang parigp>if(condition, do_if_true, do_if_false)</lang>
and short-circuit && and || (which can be abbreviated & and | if desired).
PARI can use all of the usual C conditionals.
Pascal
if-then-else
<lang pascal>IF condition1 THEN
procedure1
ELSE
procedure3;
IF condition1 THEN
BEGIN procedure1; procedure2 END
ELSE
procedure3;
IF condition1 THEN
BEGIN procedure1; procedure2 END
ELSE
BEGIN procedure3; procedure4 END;</lang>
case
Case selectors must be an ordinal type. This might seem to be a restriction, but with a little thought just about anything can be resolved to an ordinal type. Additionally, each selector may consist of more then one item. The optional ELSE keyword provides a default for values that do not match any of the given cases.
In Pascal there is no fall-through to the next case. When execution reaches the end of a matching clause, it continues after the end of the case statement, not in the code for the next case.
<lang pascal>case i of
1,4,9: { executed if i is 1, 4 or 9 }
DoSomething;
11, 13 .. 17: { executed if i is 11, 13, 14, 15, 16 or 17 }
DoSomethingElse;
42: { executed only if i is 42 }
DoSomeOtherThing;
else
DoYetAnotherThing;
end;</lang>
Given the variable "X" as a char the following is valid:
<lang pascal>Case X of
'A' : statement ; 'B' : statement ; in ['C'..'W'] : statement ;
else
Statement ;
end;</lang>
Perl
if/else
<lang perl>if ($expression) {
do_something;
}</lang>
<lang perl># postfix conditional do_something if $expression;</lang>
<lang perl>if ($expression) {
do_something;
} else {
do_fallback;
}</lang>
<lang perl>if ($expression1) {
do_something;
} elsif ($expression2) {
do_something_different;
} else {
do_fallback;
}</lang>
unless
unless behaves like if, only logically negated.
You can use it wherever you can use if. An unless block can have elsif and else blocks, but there is no elsunless.
ternary operator
The ternary operator is used as an expression within a statement, rather than as a control flow structure containing one or more statements. It is frequently used in assignment, or sometimes for passing function call arguments that vary depending on some condition.
<lang perl>$variable = $expression ? $value_for_true : $value_for_false;</lang>
logical operators
<lang perl>$condition and do_something; # equivalent to $condition ? do_something : $condition</lang>
<lang perl>$condition or do_something; # equivalent to $condition ? $condition : do_something</lang>
&& and || have the same semantics as and and or, respectively, but their precedence is much higher, making them better for conditional expressions than control flow.
switch
At first there was no switch structure in Perl, although there were plenty ways to emulate it. In Perl 5.8, an experimental switch/case/else structure was introduced. Perl 5.10 replaced this with the given/when/default structure borrowed from Perl 6.
<lang perl>use feature "switch"; given ($input) {
when (0) { print 'input == 0'; }
when ('coffee') { print 'input equal coffee'; }
when ([1..9]) { print 'input between 1 and 9'; }
when (/rats/) { print 'input matches rats'; }
default { do_fallback; }
}</lang>
Perl 6
if/else
if, else, elsif, unless, and given work much as they do in Perl 5, with the following differences:
- All the parentheses are now optional.
- unless no longer permits elsif or else blocks.
- If the block of an if, elsif, or unless has a nonzero arity, the value of the conditional expression is used as an argument to the block: <lang perl6>if won() -> $prize { say "You won $prize."; }</lang> If an else block has a nonzero arity, it receives the value of the condition tested by the last if or elsif.
given/when
Switch structures are done by topicalization and by smartmatching in Perl 6. They are somewhat orthogonal, you can use a given block without when, and vice versa. But the typical use is: <lang perl6>given lc prompt("Done? ") {
when 'yes' { return }
when 'no' { next }
default { say "Please answer either yes or not." }
}</lang> when blocks are allowed in any block that topicalizes $_, including a for loop (assuming one of its loop variables is bound to $_) or the body of a method (if you have declared the invocant as $_)." See Synopsis 4.
There are also statement modifier forms of all of the above.
Ternary operator
The ternary operator looks like this: <lang perl6>$expression ?? do_something !! do_fallback</lang>
Other short-circuiting operators
and, or, &&, || and // work as in Perl 5.
PHL
If-else:
<lang phl>var a = 5; if (a == 5) {
doSomething();
} else if (a > 0) {
doSomethingElse();
} else {
error();
}</lang>
PHP
if
Interpreter: PHP 3.x, 4.x, 5.x
<lang php><?php
$foo = 3;
if ($foo == 2)
//do something
if ($foo == 3)
//do something
else
//do something else
if ($foo != 0) {
//do something
} else {
//do another thing
}
?></lang>
switch
Interpreter: PHP 3.x & 4.x & 5.x
<lang php><?php
switch ($i) {
case "apple":
echo "i is apple";
break;
case "bar":
echo "i is bar";
break;
case "cake":
echo "i is cake";
break;
}
?></lang>
See Also
PicoLisp
Two-way conditions
<lang PicoLisp>(if (condition) # If the condition evaluates to non-NIL
(then-do-this) # Then execute the following expression (else-do-that) # Else execute all other expressions (and-more) )
(ifn (condition) # If the condition evaluates to NIL
(then-do-this) # Then execute the following expression (else-do-that) # Else execute all other expressions (and-more) )</lang>
One-way conditions <lang PicoLisp>(when (condition) # If the condition evaluates to non-NIL
(then-do-this) # Then execute tall following expressions (and-more) )
(unless (condition) # If the condition evaluates to NIL
(then-do-this) # Then execute all following expressions (and-more) )</lang>
Four-way condition
<lang PicoLisp>(if2 (condition1) (condition2) # If both conditions evaluate to non-NIL
(expression-both) # Then execute this expression (expression-first) # Otherwise this for the first (expression-second) # or this the second condition. (expression-none) # If both are NIL, all following expressions (and-more) )</lang>
Multiple conditions
<lang PicoLisp>(cond
((condition1) # If this condition evaluates to non-NIL
(expression 1) # Execute these expression(s)
(more 1) )
((condition2) # Otherwise, if this evaluates to non-NIL
(expression 2) # Execute these expression(s)
(more 2) )
(T # If none evaluated to non-NIL
(expression 1) # Execute these expression(s)
(more 1) )
(nond
((condition1) # If this condition evaluates to NIL
(expression 1) # Execute these expression(s)
(more 1) )
((condition2) # Otherwise, if this evaluates to NIL
(expression 2) # Execute these expression(s)
(more 2) )
(NIL # If none evaluated to NIL
(expression 1) # Execute these expression(s)
(more 1) )</lang>
Selection
<lang PicoLisp>(case (expression) # Evaluate the expression
(value1 # If it is equal to, or member of, 'value1'
(do-this1) # Execute these expression(s)
(do-that1) )
(value2 # Else if it is equal to, or member of, 'value2
(do-this2) # Execute these expression(s)
(do-that2) )
(T # Else execute final expression(s)
(do-something-else) ) )</lang>
PL/I
if-then-else
<lang pli>if condition_exp then unique_statement; else unique_statement;
if condition_exp then
unique_statement;
else
unique_statement;
if condition_exp then do;
list_of_statements;
end; else do;
list_of_statements;
end;</lang>
So a cascading form can be derived from: <lang pli>if condition_exp1 then
statement_1;
else if condition_exp2 then
statement_2;
else if condition_expN then
statement_N;
else
statement_E;
if condition_exp1 then do;
list_of_statements;
end; else if condition_exp2 then do;
list_of_statements;
end; else if condition_expN then do;
list_of_statements;
end; else do;
list_of_statements;
end;</lang>
case
The PL/I 'case' statement has two possible formats:
select - format 1
<lang pli>select (i); /* select on value of variable */
when (1,4,9)
do;
statement_s;
end;
when (11, 42)
do;
statement_s;
end;
other /* everything else */
do;
statement_s;
end;
end;</lang>
select - format 2
<lang pli>select; /* select first matching condition */
when (i = 4)
do;
statement_s;
end;
when (this = that)
do;
statement_s;
end;
when (mystring = 'ABCDE')
do;
statement_s;
end;
other
do;
statement_s;
end;
end;</lang>
Notes:
- in PL/I there is no fall-through to the next when. When execution reaches the end of a matching clause, it continues after the end of the select statement, not in the code for the next case.
- the do ... end statements can be omitted if the when clause is a single statement.
- if no other (or in full: otherwise) statement is present and none of the when cases is matched, the program will end in error.
Pop11
The simplest conditional is:
<lang pop11>if condition then
;;; Action
endif;</lang>
Two way conditional looks like:
<lang pop11>if condition then
;;; Action1
else
;;; Alternative action
endif;</lang>
One can do multiway choice using elseif clause
<lang pop11>if condition1 then
;;; Action1
elseif condition2 then
;;; Action1
elseif condition2 then
;;; Action2
elseif condition3 then
;;; Action3
else
;;; Alternative action
endif;</lang>
Instead of if keyword one can use unless keyword.
<lang pop11>unless condition then /* Action */ endunless;</lang>
has the same meaning as
<lang pop11>if not(condition) then /* Action */ endif;</lang>
One can also use elseunless keword.
<lang pop11>if condition1 then
;;; Action1
elseunless condition2 then
;;; Action2
endif;
;;; Action2
endif;</lang>
has the same meaning as
<lang pop11>if condition1 then
;;; Action1
elseif not(condition2) then
;;; Action2
endif;</lang>
Note that conditional must end in matching keyword, if must be finished by endif, unless must be finished by endunless (in the middle one can mix elseif with elseunless.
Pop11 conditional is an expression:
<lang pop11>if x > 0 then 1 elseif x < 0 then -1 else 0 endif -> sign_x ;</lang>
assigns sign of x to sign_x.
Instead of multiway if one can use switchon construct (which is equivalent to a special case of if, but may be shorter).
<lang pop11>switchon(x)
case .isstring then printf('A1');
notcase .isinteger then printf('A2');
case = 2 orcase = 3 then printf('A3');
case > 4 andcase < 15 then printf('A4');
else printf('A5');
endswitchon;</lang>
There is also multiway goto statement and conditional control transfers, we explain them together with other control transfers and loops (in case of loop exit/continue statements).
Pop11 also has preprocessor allowing conditional compilation:
<lang pop11>#_IF condition1 /* Variant 1 */
- _ELSEIF condition2
/* Variant 2 */
- _ELSE
/* Variant 3 */
- _ENDIF</lang>
condition1 and condition2 are arbitrary Pop11 expressions (they have access to all previously compiled code).
Also note that Pop11 syntax is user extensible, so users may create their own conditional constructs.
PostScript
The "if" operator uses two items form the stack, a procedure and a boolean. It will execute the procedure if the boolean is true. It will not leave anything on the stack (but the procedure might):
<lang postscript>9 10 lt {(9 is less than 10) show} if</lang>
The "ifelse" operator expects two procedures and executes the one or the other depending on the value of the boolean. I.e. this:
<lang postscript>/a 5 lt {(yeah)} {(nope)} ifelse show</lang>
will render either the string "yeah" or "nope" depending on whether a is less than 5 or not.
PowerShell
If, ElseIf, Else
<lang powershell># standard if if (condition) {
# ...
}
- if-then-else
if (condition) {
# ...
} else {
# ...
}
- if-then-elseif-else
if (condition) {
# ...
} elseif (condition2) {
# ...
} else {
# ...
}</lang>
Switch
<lang powershell># standard switch switch ($var) {
1 { "Value was 1" }
2 { "Value was 2" }
default { "Value was something else" }
}
- switch with wildcard matching
switch -Wildcard ($var) {
"a*" { "Started with a" }
"*x" { "Ended with x" }
}
- switch with regular expression matching
switch -Regex ($var) {
"[aeiou]" { "Contained a consonant" }
"(.)\1" { "Contained a character twice in a row" }
}
- switch allows for scriptblocks too
switch ($var) {
{ $_ % 2 -eq 0 } { "Number was even" }
{ $_ -gt 100 } { "Number was greater than 100" }
}
- switch allows for handling a file
switch -Regex -File somefile.txt {
"\d+" { "Line started with a number" }
"\s+" { "Line started with whitespace" }
}</lang>
Prolog
A "pure" Prolog program by its very nature is one very long, very complicated boolean test. Absolutely every executable portion of Prolog is a test that succeeds or fails. Here are some examples, thus, of using conditionals in Prolog:
<lang Prolog>go :- write('Hello, World!'), nl.</lang>
While operationally this looks like a program that when go/0 is executed will print "Hello, World!" and exit, it is actually a predicate, in the strict logical sense of the term, that tests conditions. Denotationally we'd describe it as "go/0 succeeds iff write/1 succeeds with its passed-in argument, and if nl/0 subsequently succeeds." (The fact that write/1 and nl/0 **always** succeed and that we use them for their side effects only doesn't matter to the Prolog view of a program.)
<lang Prolog>fact(foo). fact(bar). fact(baz).
go :- fact(booger). go :- fact(bar).</lang>
This example shows a few features of Prolog's testing and, specifically, shows nondeterminism and backtracking in action. In this we have a predicate fact/1 (so named because in this format, without an executable body, it is termed a "fact" in the literature). It has two clauses asserting both "bar" and "baz" as facts. go/0 also has two clauses. If we execute go/0, the runtime will tell us "true" (or, in some implementations, "yes") to indicate that the predicate call was successful. Denotationally we would say "fact(X) succeeds iff X unifies with foo, X unifies with bar, or X unifies with baz". We would also say "go/0 succeeds iff fact(booger) succeeds or if fact(bar) succeeds". When running, the first clause of go/0 will be executed and fact(booger) will be tested. fact(booger) does not match fact(bar) nor does it match fact(baz) so it fails. This leads the runtime to go back and try again with the **second** go/0 clause. In this one fact(bar) does, in fact, match fact(bar), so the overall test passes. A Prolog program is, thus, a very complicated tree of if/then statements, in effect.
<lang Prolog>fact(X) :-
( X = foo ; X = bar ; X = baz ).
go :-
( fact(booger) ; fact(bar) ).</lang>
This version is semantically the same as the previous one. (In actual execution, because of some runtime optimizations, there are some minor differences in outcome, but nothing that would change the logical interpretation of the program.) Here we're showing more explicitly the various "or" conditions. In Prolog "," is roughly equivalent to "and" (conjunction) while ";" is roughly equivalent to "or" (disjunction). Because of this, and because of the fact we've taken separate clauses now and put them into explicit disjunctions it is clearer that we're performing a series of if/then tests in effect.
That being said, Prolog does have something that's very akin to real if/then statements (or, more accurately, similar to the ternary operator of languages like C):
<lang Prolog>fact(X) :-
( X = bar -> write('You got me!'), nl
; write(X), write(' is not right!'), nl, fail ).
go :-
( fact(booger) ; fact(bar) ).</lang>
In this version of fact/1, the -> operator is used to perform a more traditional if/then/else. The general construct is ( condition -> succeed_branch ; fail_branch ). In this case if the parameter passed in unifies with 'bar', a message is written (recall that write/1 and nl/0 always succeed!) and the whole predicate exists with a success. If, on the other hand, the unification fails (you pass anything other than 'bar') it writes a snarky message and then calls fail/0, a predicate that, as its name suggests, always fails. There are more implications to using the conditional expression in Prolog; it is generally considered code smell. Other operators also exist for handling conditionals (like *->) that lack the "smell" of the conditional operator. The reasons for this are out of scope, however, for this article. Just know that the fact/1 predicate could have used *-> in place of -> and been more "sound" as a result.
PureBasic
If, Elseif, Else
<lang PureBasic>If a = 0
Debug "a = 0"
ElseIf a > 0
Debug "a > 0"
Else
Debug "a < 0"
EndIf</lang>
Select
<lang PureBasic>Variable = 2
Select Variable
Case 0 Debug "Variable = 0"
Case 10, 11, 99 Debug "Variable is 10, 11 or 99"
Case 20 To 30 Debug "Variable >= 20 And Variable <= 30"
Default Debug "Variable = something else..."
EndSelect</lang>
CompilerIf
Compiler conditional structures works like normal conditional structures, except they are evaluated at compile time, and thus have to use constant expressions. Any defined constant can be used, these examples uses built-in constants. <lang PureBasic> CompilerIf #PB_Compiler_OS = #PB_OS_Linux And #PB_Compiler_Processor = #PB_Processor_x86
Debug "Compiled on x86 Linux"
CompilerElse
Debug "Compiled on something else"
CompilerEndIf </lang>
CompilerSelect
<lang PureBasic> CompilerSelect #PB_Compiler_OS
CompilerCase #PB_OS_Linux Debug "Compiled on Linux" CompilerCase #PB_OS_Windows Debug "Compiled on Windows" CompilerCase #PB_OS_MacOS Debug "Compiled on Mac OS" CompilerDefault Debug "Compiled on something else"
CompilerEndIf </lang>
Python
if-then-else
<lang python>if x == 0:
foo()
elif x == 1:
bar()
elif x == 2:
baz()
else:
boz()</lang>
ternary expressions
Interpreter: Python 2.5
<lang python>true_value if condition else false_value</lang>
Example: <lang python>>>> secret='foo' >>> print 'got it' if secret=='foo' else 'try again' 'got it'</lang>
Note: this syntax is valid as an expression, the clauses cannot constain statements. The foregoing example is equivalent to:
<lang python>>>> secret = 'foo' >>> result = 'got it' if secret=='foo' else 'try again' >>> print result 'got it'</lang>
Function dispatch dictionary
In some cases it's useful to associate functions with keys in a dictionary; and simply use this in lieu of long sequences of "if...elif...elif..." statements.
<lang python>dispatcher = dict() dispatcher[0]=foo # Not foo(): we bind the dictionary entry to the function's object,
# NOT to the results returned by an invocation of the function
dispatcher[1]=bar dispatcher[2]=baz # foo,bar, baz, and boz are defined functions.
- Then later
results = dispatcher.get(x, boz)() # binding results to a name is optional
- or with no "default" case:
if x in dispatcher:
results=dispatcher[x]()</lang>
<lang python># The above, but with a dict literal dispatcher = {
0: foo, 1: bar, 2: baz,
}
- ...
results = dispatcher.get(x, boz)()</lang>
<lang python># Or without the temp variable
- (it's up to the reader to decide how "pythonic" this is or isn't)
results = {
0: foo, 1: bar, 2: baz,
}.get(x, boz)()</lang>
This can be particularly handy when using currying techniques, or when lambda expressions or meta-function generators (factories) can be used in place of normal named functions.
In general a dispatch table or class/object abstraction (using dynamic method over-rides) is considered preferable to chains of if ... elif ... elif ... in Python programming.
Racket
if
If-expressions in Racket must have both branches <lang racket> (if (< x 10)
"small" "big")
</lang>
when/unless
One-sided conditional expressions use "when" and "unless". These are more convenient for side-effects since they have an implicit "begin" around their body, and you can also include new definitions <lang racket> (when (< x 10)
(define y (* x 10)) (printf "small\n"))
</lang>
cond
Used for multiple conditions: <lang racket> (printf "x is ~a\n"
(cond [(< x 1) "tiny"]
[(< x 10) "small"]
[(< x 100) "medium"]
[(< x 10000) "big"]
[(< x 100000000) "huge"]
[else "gigantic"]))
</lang>
case
Similar to a "switch" statement in other languages <lang racket> (case x
[(1) "one"] [(2) "two"] [(3) "three"] [(4) "four"] [(6 8) "even"] [(5 7 9) "odd"] [else "something else"])
</lang>
etc
Racket has macros, which means that you can define whatever new conditional you think is useful...
Retro
if, ifTrue, and ifFalse
<lang Retro>( condition ) [ ( true statements ) ] ifTrue ( condition ) [ ( false statements ) ] ifFalse ( condition ) [ ( true statements ) ] [ ( false statements ) ] if</lang>
These forms can be used interactively, or inside function definitions.
when
<lang Retro>: foo ( n- )
[ 1 = ] [ drop ( if quote evaluates to true ) ] when [ 2 = ] [ drop ( if quote evaluates to true ) ] when [ 3 = ] [ drop ( if quote evaluates to true ) ] when drop ( default action ) ;</lang>
REXX
IF--THEN, IF--THEN--ELSE
<lang rexx>if y then @=6 /* Y must be either 0 or 1 */
if t**2>u then x=y /*simple IF with THEN & ELSE. */
else x=-y
if t**2>u then do j=1 for 10; say prime(j); end /*THEN DO loop.*/
else x=-y /*simple ELSE. */
if z>w+4 then do /*THEN DO group.*/
z=abs(z)
say 'z='z
end
else do; z=0; say 'failed.'; end /*ELSE DO group.*/
if x>y & c*d<sqrt(pz) |, /*this statement is continued [,]*/
substr(abc,4,1)=='~' then if z=0 then call punt
else nop /*NOP pairs up IF*/
else if z<0 then z=-y /*alignment helps*/</lang>
SELECT--WHEN
<lang rexx> /*the WHEN conditional operators are the same as*/
/*the IF conditional operators. */
select
when t<0 then z=abs(u)
when t=0 & y=0 then z=0
when t>0 then do
y=sqrt(z)
z=u**2
end
/*if control reaches here & none of the WHENs were*/
/*satisfiied, a SYNTAX (error) condition is raised*/
end /*1st select*/
select
when a=='angel' then many='host'
when a=='ass' | a=='donkey' then many='pace'
when a=='crocodile' then many='bask'
when a=='crow' then many='murder'
when a=='lark' then many='ascension'
when a=='quail' then many='bevy'
when a=='wolf' then many='pack'
otherwise many='?'
end /*2nd select*/ /* [↑] uses OTHERWISE as a catch-all.*/</lang>
SELECT--WHEN/OTHERWISE
<lang rexx> select
when g=='angel' then many='host'
when g=='ass' | g=='donkey' then many='pace'
when g=='crocodile' then many='bask'
when g=='crow' then many='murder'
when g=='lark' then many='ascension'
when g=='quail' then many='bevy'
when g=='wolf' then many='pack'
otherwise say
say '*** error! ***'
say g "isn't one of the known thingys."
say
exit 13
end /*select*/</lang>
Rhope
if-then-else
<lang rhope>If[cond] |:
Do Something[]
- ||:
Do Something Else[]
- |</lang>
RLaB
if
Block of instructions following the if command has to be always enclosed in curly brackets. <lang RLaB> if (x==1) {
// do something
} </lang>
if-else
If there are branching within the command, respective blocks have to be enclosed in the blocks preceding it. Consider an example:
<lang RLaB> if (x==1) {
// do something if x is 1 y = const.pi;
else
// do something if x is not 1 y = sin(const.pi*(1-x)) / (1-x);
} </lang>
<lang RLaB> if (x==1) {
// do something if x is 1 y = const.pi;
else if (x == 2) {
// do something if x is 2 y = sin(const.pi*(1-x)) / (1-x);
else
// do something in all the other cases y = rand();
}} </lang>
Ring
if-but-else-ok <lang ring>If x == 1
SomeFunc1()
But x == 2
SomeFunc2()
Else
SomeFunc()
Ok</lang>
Switch <lang ring>Switch x On 1
SomeFunc1()
On 2
SomeFunc2()
Other
SomeFunc()
Off</lang>
Ruby
See Conditional Structures/Ruby
Run BASIC
<lang Runbasic>' Boolean Evaluations ' ' > Greater Than ' < Less Than ' >= Greater Than Or Equal To ' <= Less Than Or Equal To ' = Equal to
x = 0
if x = 0 then print "Zero"
' -------------------------- ' if/then/else if x = 0 then print "Zero" else print "Nonzero" end if
' -------------------------- ' not if x then print "x has a value." end if if not(x) then print "x has no value." end if
' -------------------------- ' if .. end if if x = 0 then print "Zero" goto [surprise] end if wait
if x = 0 then goto [surprise] print "No surprise." wait
[surprise] print "Surprise!" wait
' -------------------------- ' case numeric num = 3
select case num case 1 print "one"
case 2 print "two"
case 3 print "three"
case else print "other number"
end select
' -------------------------- ' case character var$="blue"
select case var$
case "red" print "red"
case "green" print "green"
case else print "color unknown"
end select</lang>
Sather
<lang sather> if EXPR then
-- CODE
elsif EXPR then
-- CODE
else
-- CODE
end;</lang>
EXPR must evaluate to BOOL (true or false); elsif and else are optional.
<lang sather> case EXPR
when EXPRL then
-- CODE
when EXPRL then
-- CODE
else
-- CODE
end;</lang>
EXPRL is a single expression or a comma-separated list of exressions. The expressions must evaluate to comparable objects (the method is_eq must be implemented)
Scala
<lang Scala> if (n == 12) "twelve" else "not twelve"
today match {
case Monday =>
Compute_Starting_Balance;
case Friday =>
Compute_Ending_Balance;
case Tuesday =>
Accumulate_Sales
case _ => {}
}</lang>
Scheme
Procedures can be categorised as primitive or derived. Derived procedures can be defined in terms of primitive procedures.
Primitive
if
<lang>(if <test> <consequent> <alternate>)</lang> <lang>(if <test> <consequent>)</lang> Example: <lang scheme>(display
(if (> 1 2)
"yes"
"no"))
(newline) (display
(if (> 1 2)
(- 1 2)))
(newline)</lang>
- Output:
no #<unspecified>
Derived
cond
<lang>(cond <clause1> <clause2> ...)</lang> Example: <lang scheme>(display
(cond ((> 1 2) "greater")
((< 1 2) "less")))
(newline) (display
(cond ((> 1 1) "greater")
((< 1 1) "less")
(else "equal")))
(newline)</lang>
- Output:
less equal
case
<lang>(case <key> <clause1> <clause2> ...)</lang> Example: <lang scheme>(display
(case (* 2 3) ((2 3 5 7) "prime") ((1 4 6 8 9) "composite")))
(newline) (display
(case (car (list c d)) ((a e i o u) "vowel") ((w y) "semivowel") (else "consonant")))
(newline)</lang>
- Output:
composite consonant
Scilab
if-then-else
if condition1 then instructions1 [elseif condition2 then instructions2] .... [else instructionse] end
select-case
select expression case expression1 then instructions1 [case expression2 then instructions2] ... [else instructionse] end
Seed7
if-then-else
There can be single or multiple statements. An if-statement can have multiple elsif parts. <lang seed7>if condition then
statement
end if;
if condition then
statement1
else
statement2;
end if;
if condition1 then
statement1
elsif condition2 then
statement2;
end if;
if condition1 then
statement1
elsif condition2 then
statement2;
else
statement3;
end if;</lang>
case
<lang seed7>case i of
when {1, 4, 9}: # Executed if i is 1, 4 or 9
statement1;
when {11} | {13 .. 17}: # Executed if i is 11, 13, 14, 15, 16 or 17
statement2;
when {42}: # Executed only if i is 42
statement3;
otherwise:
statement4;
end case;</lang>
SIMPOL
if-else if-else
<lang simpol>if x == 1
foo()
else if x == 2
bar()
else
foobar()
end if</lang>
ternary if function
<lang simpol>.if(x == 1, "hello", "world")</lang>
Simula
Simula 67 has conditional statements of the form:
statement::= if conditional_expression then statement else statement if X=Y then K:=I else K:=J statement::= if conditional_expression then statement if X=Y then K:=I
An example: <lang simula>BEGIN
INTEGER i,j;
i:=1; j:=2;
OutText("i ");
IF i=1 THEN OutInt(i,1);
OutImage;
OutInt(i,2); OutInt(j,2);
IF i<j THEN OutText(" : i<j") ELSE OutText(" : i>=j");
OutImage;
IF i>=j THEN BEGIN
OutText("i=");
OutInt(i,5)
END
ELSE BEGIN
OutText("j=");
OutInt(j,5)
END;
OutImage
END</lang> Simula 67 has also a switch structure:
declaration::= switch switch:=list_of labels statement::= goto switch[expression]
An example: <lang simula>BEGIN
INTEGER i,j;
SWITCH target:=L1,L2,L3;
i:=1; j:=2;
OutText("::");
GOTO target(j);
L1: OutText("AA");
L2: OutText("BB");
L3: OutText("CC");
OutImage
END</lang>
Slate
ifTrue/ifFalse
<lang slate>"Conditionals in Slate are really messages sent to Boolean objects. Like Smalltalk. (But the compiler might optimize some cases)"
balance > 0
ifTrue: [inform: 'still sitting pretty!'.]
ifFalse: [inform: 'No money till payday!'.].</lang>
caseOf:otherwise:
<lang slate>c@(Net URLPathEncoder traits) convert [ | byte1 byte2 byte3 digit1 digit2|
[c in isAtEnd] whileFalse:
[byte1: c in next.
byte1 caseOf: {
$+ -> [c out nextPut: $\s].
$% -> [byte2: c in next.
byte3: c in next.
digit1: (byte2 toDigit: 16).
digit2: (byte3 toDigit: 16).
digit1 isNil \/ [digit2 isNil] ifTrue: [error: 'Error reading hex sequence after %'].
c out nextPut: (digit1 * 16 + digit2 as: c out elementType)].
} otherwise: [c out nextPut: byte1].
].
].</lang>
whileTrue:/whileFalse:
<lang slate>[p isAtEnd] whileFalse: [p next evaluate]].</lang>
Smalltalk
The pattern for handling a multi-option switch is to create classes for the various options, and let Polymorphism take care of the decisions.
ifTrue/ifFalse
<lang smalltalk>"Conditionals in Smalltalk are really messages sent to Boolean objects"
balance > 0
ifTrue: [Transcript cr; show: 'still sitting pretty!'.]
ifFalse: [Transcript cr; show: 'No money till payday!'.].</lang>
You can also use them as the ternary operator
<lang smalltalk>abs := x > 0 ifTrue: [ x ] ifFalse: [ x negated ]</lang>
SNOBOL4
SNOBOL4 has no structured programming features, but the two constructs in question could be easily emulated with FAILURE/SUCCESS and indirect jumps
<lang snobol> A = "true"
- "if-then-else"
if A "true" :s(goTrue)f(goFalse) goTrue output = "A is TRUE" :(fi) goFalse output = "A is not TRUE" :(fi) fi
- "switch"
switch A ("true" | "false") . switch :s($("case" switch))f(default) casetrue output = "A is TRUE" :(esac) casefalse output = "A is FALSE" :(esac) default output = "A is neither FALSE nor TRUE" esac end</lang>
SNUSP
<lang snusp>$==?\==zero=====!/==#
\==non zero==/</lang>
? is the only conditional operator. It skips one character if the current cell is zero.
! is an unconditional skip. !/ is the idiom for joining two lines of execution. ?! inverts the test.
\ and / redirect the flow of control. All the other characters besides $ and # are commentary.
Sparkling
If statement:
<lang sparkling>var odd = 13; if odd % 2 != 0 {
print("odd");
}</lang>
If-else statement:
<lang sparkling>var odd = 13; if odd % 2 != 0 {
print("odd");
} else {
print("even");
}</lang>
If and if-else statements can be chained:
<lang sparkling>var nodiv3 = 13; if nodiv3 % 3 == 0 {
print("divisible by 3");
} else if nodiv3 % 3 == 1 {
print("gives 1 remainder");
} else {
print("gives 2 remainder");
}</lang>
There's no "switch-case" statement in Sparkling yet, but it's work in progress.
SQL
Conditional Expression
<lang sql>case when a then b else c end
declare @n int set @n=124 print case when @n=123 then 'equal' else 'not equal' end
--If/ElseIf expression set @n=5 print case when @n=3 then 'Three' when @n=4 then 'Four' else 'Other' end</lang>
If/Else
<lang sql>declare @n int set @n=123 if @n=123
BEGIN --begin/end needed if more than one statement inside print 'one two three' END
ELSE
if @n=124 print 'one two four' else print 'other'</lang>
SSEM
The SSEM's only conditional operation is 011 Test, which causes the computer to skip the next instruction if the value held in the accumulator is negative. This program illustrates it: assuming address 10 stores a variable, we test whether its negation is negative (i.e. whether the variable itself is positive). If it is, we skip the next instruction and proceed with the program; but, if it is not negative (i.e. the variable is negative or zero), we jump to address 1 + the value stored at address 14. It is easy to see how this can be used to implement loops, other conditional tests, etc. <lang ssem>01010000000000100000000000000000 -10 to c 00000000000000110000000000000000 Test 01110000000000000000000000000000 14 to CI</lang>
Tcl
if-then-else
<lang tcl>if {$foo == 3} {
puts "foo is three"
} elseif {$foo == 4} {
puts "foo is four"
} else {
puts "foo is neither three nor four"
}</lang> or (using the ternary operator of expressions) <lang tcl>set result [expr { $foo == 3 ? "three" : "not three" }]</lang>
switch
<lang tcl>switch -- $foo {
3 {puts "foo is three"}
4 {puts "foo is four"}
default {puts "foo is something else"}
}</lang> Note that the switch command can also use glob matching (like case in the Bourne Shell) or regular-expression matching.
TI-83 BASIC
There are 3 forms of conditional statement:
Basic form
with only one statement for the true part:
<lang ti83b>If condition
statement</lang>
or in one line
<lang ti83b>If condition : statement</lang>
If-Then form <lang ti83b>If condition Then statements End</lang>
If-Then-Else form <lang ti83b>If condition Then statements Else statements End</lang>
Toka
ifTrue
( condition ) ( quote ) ifTrue
<lang toka>100 100 = [ ." True\n" ] ifTrue 100 200 = [ ." True\n" ] ifTrue</lang>
ifFalse
( condition ) ( quote ) ifFalse
<lang toka>100 100 = [ ." True\n" ] ifFalse 100 200 = [ ." True\n" ] ifFalse</lang>
ifTrueFalse
( condition ) ( true quote ) ( false quote ) ifTrueFalse
<lang toka>100 100 = [ ." Equal\n" ] [ ." Not Equal\n" ] ifTrueFalse 100 200 = [ ." Equal\n" ] [ ." Not Equal\n" ] ifTrueFalse</lang>
TorqueScript
if-then-else
<lang tqs>// numbers and objects if(%num == 1) { foo(); } else if(%obj == MyObject.getID()) { bar(); } else { deusEx(); }
// strings if(%str $= "Hello World") { foo(); } else if(%str $= "Bye World") { bar(); } else { deusEx(); }</lang>
switch
<lang tqs>// numbers and objects switch(%num) { case 1: one(); case 2: twoThreeOrFour(); case 3: twoThreeOrFour(); case 4: twoThreeOrFour(); case 5: five(); case MyObject.getID(): anObject(); default: everythingElse(); }
// strings switch$(%str) { case "Hello": arrival(); case "Goodbye": departure(); default: somethingElse(); }</lang>
conditional (ternary) operator (?:)
<lang tqs>%formatted = %str @ ((getSubStr(%str,strLen(%str) - 1,1) $= "s") ? "'" : "'s");</lang>
Trith
branch
<lang trith>true ["yes" print] ["no" print] branch</lang>
when
<lang trith>true ["yes" print] when</lang>
unless
<lang trith>false ["no" print] unless</lang>
TUSCRIPT
IF ELSEIF ELSE ENDIF
<lang tuscript> $$ MODE TUSCRIPT
condition="c" IF (condition=="a") THEN
---> do something
ELSEIF (condition=="b") THEN
---> do something
ELSE
---> do something
ENDIF </lang>
SELECT CASE DEFAULT ENDSELECT
<lang tuscript> $$ MODE TUSCRIPT
days="Monday'Tuesday'Wednesday'Thursday'Friday'Saturday'Sunday" dayofweek=DATE (today,day,month,year,number) day=SELECT (days,#dayofweek)
SELECT day CASE "Monday"
---> do something
CASE "Saturday","Sunday"
---> do something
DEFAULT
---> do something
ENDSELECT </lang>
TXR
In TXR, most directives are conditionals, because they specify some kind of match. Given some directive D, the underlying logic in the language is, roughtly, "if D does not match at the current position in the input, then fail, otherwise the input advances according to the semantics of D".
An easy analogy to regular expressions may be drawn. The regex /abc/ means something like "if a doesn't match, then fail, otherwise consume a character and if b doesn't match, then fail, otherwise consume another character and if c doesn't match, then fail otherwise consume another character and succeed." The expressive power comes from, in part, not having to write all these decisions and book-keeping.
The interesting conditional-like structures in TXR are the parallel directives, which apply separate clauses to the same input, and then integrate the results in various ways.
For instance the choose construct will select, from among those clauses which match successfully, the one which maximizes or minimizes the length of an extracted variable binding:
<lang txr> @(choose :shortest x) @x:@y @(or) @x<--@y @(or) @x+@y @(end)</lang>
Suppose the input is something which can match all three patterns in different ways:
foo<--bar:baz+xyzzy
The outcome (with txr -B) will be:
x="foo" y="bar:baz+xyzzy"
because this match minimizes the length of x. If we change this to :longest x, we get:
x="foo<--bar:baz" y="xyzzy"
The cases, all and none directives most resemble control structures because they have short-circuiting behavior.
For instance:
<lang txr>@(all) @x:y@ @z<-@w @(and) @(output) We have a match: (x, y, z, w) = (@x, @y, @z, @w). @(end) @(end)</lang>
If any subclause fails to match, then all stops processing subsequent clauses. There are subtleties though, because an earlier clause can produce variable bindings which are visible to later clauses.
If previously bound variable is bound again, it must be to an identical piece of text:
<lang txr>@# match a line which contains some piece of text x @# after the rightmost occurence of : such that the same piece @# of text also occurs at the start of the line preceded by --> @(all) @*junk:@x @(and) -->@x@/.*/ @(end)</lang>
$ echo "-->asdfhjig:asdf" | txr -B weird.txr - junk="-->asdfhjig" x="asdf" $ echo "-->assfhjig:asdf" | txr -B weird.txr - false $
UNIX Shell
If conditionals
The basic syntax is if command-list; then command-list; fi. If the first command list succeeds (by returning 0 for success), then the shell runs the second command list.
<lang sh>if test 3 -lt 5; then echo '3 is less than 5'; fi</lang>
Else and elif
There are optional elif (else if) and else clauses.
<lang sh>if test 4 -ge 6; then echo '4 is greater than or equal to 6' elif test 4 -lt 6; then echo '4 is less than 6' else echo '4 compares not to 6' fi</lang>
Switch conditionals
The Unix shell provides support for multibranch switch conditional constructs using the case statement:
<lang sh>case value in
choicea) foo ;; choiceb) bar ;;
esac</lang>
Conditional branching using operators
One can also use && and || as conditional structures; see short-circuit evaluation#UNIX Shell.
<lang sh>test 3 -lt 5 && echo '3 is less than 5' test 4 -ge 6 || echo '4 is not greater than or equal to 6'</lang>
Conditional loops
The Unix shell also supports conditional loops:
<lang sh># This is a while loop l=1 while [ l -le 5 ]; do
echo $l
done
- This is an until loop
l=1 until [ l -eq 5 ]; do
echo $l
done</lang>
C Shell
The single-line if syntax is if (expression) simple-command.
<lang csh>if (3 < 5) echo '3 is less than 5' if ({ grep -q ^root: /etc/passwd }) echo 'passwd has root'</lang>
The multi-line if syntax has a then clause, and can have optional else if and else clauses. Each clause may contain multiple commands.
<lang csh>if (4 >= 6) then echo '4 is greater than or equal to 6' else if (4 < 6) then echo '4 is less than 6' else echo '4 compares not to 6' endif</lang>
V
ifThenElse
<lang v>[true]
['is true' puts] ['is false' puts]
ifte
=is true</lang>
ifThen
<lang v>[true]
['is true' puts]
if =is true</lang>
When
<lang v>3 [
[1 =] [1 *] [2 =] [10 *] [3 =] [100 *] [4 =] [1000 *]
] when
=300</lang>
Choice
<lang v>true
1 2
choice
=1
false
1 2
choice
=2</lang>
VBScript
if-then-else
Block form: <lang vb>If condition1 Then
statement
End If
If condition1 Then
statement
ElseIf condition2 Then
statement
... ElseIf conditionN Then
statement
Else
statement
End If </lang> Line form: <lang vb>If condition Then statement
If condition Then statement Else statement</lang>
select-case
<lang vb>Select Case Expression
Case Value1: statement Case Value2: statement ... Case ValueN: statement Case Else: statement
End Select
Select Case Expression
Case Value1
statements
Case Value2
statements
...
Case ValueN
statements
Case Else
statements
End Select</lang>
Visual Basic .NET
if-then-else
Basic <lang vbnet>Dim result As String, a As String = "pants", b As String = "glasses"
If a = b Then
result = "passed"
Else
result = "failed"
End If</lang>
Condensed <lang vbnet>Dim result As String, a As String = "pants", b As String = "glasses"
If a = b Then result = "passed" Else result = "failed"
If a = b Then
result = "passed"
Else : result = "failed" End If
If a = b Then : result = "passed" Else
result = "failed"
End If</lang>
if-then-elseif
<lang vbnet>Dim result As String, a As String = "pants", b As String = "glasses"
If a = b Then
result = "passed"
ElseIf a <> b Then
result = "failed"
Else
result = "impossible"
End If</lang>
select-case-else
<lang vbnet>Dim result As String, a As String = "pants", b As String = "glasses"
Select Case a
Case b result = "match" Case a : result = "duh" Case Else result = "impossible"
End Select</lang>
inline-conditional
<lang vbnet>Imports Microsoft.VisualBasic
...
Dim result As String = CType(IIf("pants" = "glasses", "passed", "failed"), String) 'VB 1-8
Dim result As String = If("pants" = "glasses", "passed", "failed") 'VB 9</lang>
generic-inline-conditional
<lang vbnet>Imports Microsoft.VisualBasic
...
Function IIf2(Of T)(ByVal condition As Boolean, ByVal truepart As T, ByVal falsepart As T) As T
If condition Then Return truepart Else Return falsepart
End Function
...
Dim result As String = IIf2("pants" = "glasses", "passed", "failed") ' type is inferred</lang>
generic-inline-conditional
Language Version: 9.0+
<lang vbnet>Dim result As String = If("pants" = "glasses", "passed", "failed") ' type is inferred</lang>
Vorpal
if-then-else
<lang vorpal>if(condition){
result = 'met'
} else{
result = 'not met'
}</lang>
Wrapl
simple conditional
Conditionals in Wrapl are expressions. Either success or failure can be omitted from the expression. <lang wrapl>condition => success // failure condition => success condition // failure</lang>
goal directed evaluation
Wrapl's goal directed evaluation can be used to control conditional execution. The select-right operator & produces the values of the right operand for each value produced by the left operand. Thus if the left operand fails to produce any values, the right operand is never evaluated. <lang wrapl>condition & success</lang> The sequence operator | produces the values of the left operand followed by the values of the right operand. Thus if the left operand produces enough values (for example in a context where only one value is required), the right operand is never evaluated. <lang wrapl>condition | failure</lang>
X86 Assembly
ifs/elseifs/elses
Assembly doesn't work on if/else if/else statements(Unless you're using MASM or alike assemblers:)). Rather, it has conditional jumps which work off flags set by the comparison. Take this general statement from C. <lang c> if(i>1)
DoSomething
FailedSoContinueCodeExecution. </lang> There are actually a number of ways to implement that in assembly. The most typical way would be something like.. <lang asm> cmp i, 1 jg _DoSomething FailedSoContinueCodeExecution </lang> Using the "jg" instruction,our code will jump to _DoSomething if the comparison(cmp i,1) made our ZF(ZeroFlag) flag well, zero. Which means only 1 thing. It is in fact greater than. In contrast, if i is in fact equal or less than 1, ZF is set to 1. The Zero Flag will remain set as long as we don't use any instructions that alter flags(comparisons for example). So, here's another C example <lang c> if(i>1)
DoSomething
else if(i<=1)
DoSomethingElse
FailedSoContinueCodeExecution
</lang>
In this case, we can use our previous example as a skeleton.
<lang asm>
cmp i, 1
jg _DoSomething
jle _DoSomethingElse
FailedSoContinueCodeExecution
</lang>
This does another state check on the Zero flag(actually jg/jle also check another flag, but that's not overly important) using jle. JumpifLessthanorEqual. Essentially, jle jumps if ZG is set to 1. So, it's jump condition is the opposite to jg.
One last commonly used condition.
<lang c>
if(i==1)
DoSomething
else
DoSomethingElse
FailedSoContinueExecution </lang>
In this case, we'd do this.
<lang asm>
cmp i, 1
je _DoSomething
jne _DoSomethingElse
FailedSoContinueExecution
</lang>
The je/jne jump instructions are again like jg/jle opposites of each other and again like je/jne rely on how the zero flag is set in the previous comparison.
There are many different conditional jumps in assembly and many ways to set them, test, and, or to name a few. The ones covered are just some commonly used ones in order to show how assembly deals with conditional statements.
XPL0
if BOOLEAN EXPRESSION then STATEMENT
if BOOLEAN EXPRESSION then STATEMENT else STATEMENT
if BOOLEAN EXPRESSION then EXPRESSION else EXPRESSION
case INTEGER EXPRESSION of
INTEGER EXPRESSION, ... INTEGER EXPRESSION: STATEMENT;
...
INTEGER EXPRESSION, ... INTEGER EXPRESSION: STATEMENT
other STATEMENT
case of
BOOLEAN EXPRESSION, ... BOOLEAN EXPRESSION: STATEMENT;
...
BOOLEAN EXPRESSION, ... BOOLEAN EXPRESSION: STATEMENT
other STATEMENT
XSLT
The <xsl:if> element allows simple conditional processing. <lang xml><xsl:if test="condition"> </xsl:if></lang> The <xsl:choose>, <xsl:when>, and <xsl:otherwise> elements allow more general conditional processing. <lang xml><xsl:choose>
<xsl:when test="condition1"> </xsl:when> <xsl:when test="condition2"> </xsl:when> <-- ... --> <xsl:otherwise> </xsl:otherwise>
</xsl:choose></lang>
The XPath expressions in the test attribute are evaluated in boolean context (converted as if by the boolean function if necessary).
<lang xml><xsl:if test="@attrib = 'foo'">...</xsl:if> <xsl:if test="position() != last()">...</xsl:if> <xsl:if test="not(false())">...</xsl:if>
<xsl:if test='contains(node, "stuff") and (position() > first())'>...</xsl:if>
<xsl:if test="boolean($expr)">...</xsl:if> <xsl:if test="$expr">...</xsl:if></lang>
zkl
<lang zkl>if (x) y else z; if(a)b else if (c) else d; etc x:=(if (a) b else c);
a and b or c // usually the same as if(a) b else c, beware if b evals to False
switch(x){
case(1){...}
case("2"){...} // matches anything
case(a)[fallthrough]{...} // no break, no break has to be explicit
case(b){...}
else {...} // case a C's default, has to be at the end
}</lang>
- Programming Tasks
- Control Structures
- Simple
- 360 Assembly
- 6502 Assembly
- ActionScript
- Ada
- Aikido
- Aime
- ALGOL 60
- ALGOL 68
- ALGOL W
- AmbientTalk
- AmigaE
- Apex
- AppleScript
- AutoHotkey
- AutoIt
- AWK
- Axe
- Babel
- BASIC
- BBC BASIC
- Beeswax
- Befunge
- Bori
- Bracmat
- Brainf***
- Burlesque
- C
- C++
- Clean
- Clipper
- Clojure
- CMake
- COBOL
- CoffeeScript
- ColdFusion
- Comal
- Common Lisp
- Crack
- C sharp
- Batch File
- D
- Dao
- Déjà Vu
- Deluge
- Delphi
- DWScript
- E
- Efene
- Ela
- Erlang
- Factor
- FALSE
- Fancy
- Forth
- Fortran
- Friendly interactive shell
- GAP
- Go
- Harbour
- Haskell
- HicEst
- IDL
- Icon
- Unicon
- Inform 7
- J
- Java
- JavaScript
- Jq
- LabVIEW
- LC3 Assembly
- Lisaac
- Little
- Logo
- LSE64
- Lua
- Make
- Maple
- Mathematica
- MATLAB
- Maxima
- MAXScript
- MBS
- Metafont
- МК-61/52
- Modula-2
- Modula-3
- Monicelli
- Morfa
- MUMPS
- Nemerle
- NetRexx
- NewLISP
- Nim
- Object Pascal
- Objective-C
- Objeck
- OCaml
- Octave
- Oforth
- OoRexx
- OxygenBasic
- Oz
- PARI/GP
- Pascal
- Perl
- Perl 6
- PHL
- PHP
- PicoLisp
- PL/I
- Pop11
- PostScript
- PowerShell
- Prolog
- PureBasic
- Python
- Racket
- Retro
- REXX
- Rhope
- RLaB
- Ring
- Ruby
- Run BASIC
- Sather
- Scala
- Scheme
- Scilab
- Seed7
- SIMPOL
- Simula
- Slate
- Smalltalk
- SNOBOL4
- SNUSP
- SQL
- SSEM
- Tcl
- TI-83 BASIC
- Toka
- TorqueScript
- Trith
- TUSCRIPT
- TXR
- UNIX Shell
- C Shell
- V
- VBScript
- Visual Basic .NET
- Vorpal
- Wrapl
- X86 Assembly
- XPL0
- XSLT
- Zkl
- GUISS/Omit
- Branches