Conditional structures: Difference between revisions

{{Control Structures}}

[[Category:Simple]]

 

;Task:

=={{header|11l}}==

===if-else===

foo()

E I x == 1

bar()

E

 

===switch===

0

foo()

bar()

E

 

=={{header|360 Assembly}}==

Here are the branch mnemonic opcodes:

B label Unconditional

BR Rx "

BNMR Rx "

BNZ label Branch if Not Zero

The ASM (Assembler Structured Macros) toolkit brings structures to IBM assembler 360.

opcode,op1,rel,op2

opcode,op1,rel,op2,OR,opcode,op1,rel,op2

CASE 7 case 7

LA R5,4 r5=4

 

=={{header|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:

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.

BEQ ;Branch on EQual - branch when the zero flag is set.

;The zero flag is set when the result of an operation is zero

;a subtraction produced a borrow and cleared if an addition/subtraction

;does not produce a carry/borrow. The carry flag also holds bits

In the following example, the branch will be taken if memory location Variable holds 200:

CMP Variable

BEQ #3 ;if equal, skip ahead 3 bytes...

CLC ;if unequal, continue executing instructions

ADC #1

Because you don't have to perform a comparison to set the flags, you can perform very fast checks in iterative loops:

Loop: ...do something

DEX

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.

A jump table is a list of subroutine addresses, which can be indexed like any other array. The 6502 has no indirect call command, but it can be created in software using an indexed jump table. One method of doing this is spoofing a return address and using the return from subroutine command to "return" to the desired subroutine.

 

dw foo-1 ;each is a label to a section of code that ends in an RTS

dw bar-1

; If done properly, return spoofing will not corrupt the stack.

 

=={{header|68000 Assembly}}==

Like [[6502 Assembly]], 68000 Assembly has several different condition states the CPU can use to branch. As is typical with assembly languages, branching code is less straightforward than on high-level languages. There is no "if" statement per se; the correct branch to use depends more so on the expression being evaluated.

===CMP===

The most commonly used comparator is <code>CMP</code>. It can operate at byte, word, or long length. Anything outside of the "range" of its size parameter is ignored.

CMP.B #0,D0 ;equals zero, so zero flag is set.

 

Other than its size parameter, <code>CMP</code> works very similar to [[6502 Assembly]]. It returns both a test for equality and a size comparison (i.e. which number is greater than the other.) This chart from [http://www.easy68k.com/paulrsm/doc/trick68k.htm 68000 Tricks and Traps] sums it up nicely. If you use <code>CMP D0,D1</code> at any data size, this is what you get:

===Bit Testing===

Individual bits can be tested with <code>BTST</code>, <code>BSET</code>, <code>BCLR</code>, and <code>BCHG</code>. The <code>BTST</code> command takes a bit as its left operand and the value being tested in the right (either a data register, address register with or without parentheses, or memory address).

BNE goHere ;if that bit is 1, branch to "goHere"

 

<code>BSET</code>, <code>BCLR</code>, and <code>BCHG</code> are similar, in that they also allow you to branch based on the value of the bit being tested. However, they also alter the bit in the destination that was tested, AFTER the test. The new state of that bit is not reflected in the test results. Branching occurs as if you used <code>BTST</code> instead. <code>BSET</code> makes the bit in the destination 1, <code>BCLR</code>makes it zero, and <code>BCHG</code> flips it.

These concepts can be emulated in assembly but it's a bit tricky for beginners to understand. The branch condition isn't always what you would expect. Sometimes it is reversed depending on what is easier to check. This is a common way to have an <code>IF condition==true THEN do something ELSE do nothing</code> style of statement. The code checks if <code>D0 == 3</code> and if it does, adds 7. If <code>D0 != 3</code>, execution just continues as normal.

 

BNE doNothing

ADD.L #7,D0

doNothing:

 

Rather than branch to a different section of code if <code>D0 == 3</code>, the program branched if it <b>DIDN'T</b> equal 3, skipping the add 7.

There is no built-in way to "default" if none of the expected cases match. A bounds check will have to be programmed in manually. Most of the time when writing a return spoof the programmer already knows what the maximum possible cases will be.

 

DC.L foo,bar,baz,default ;case 0, case 1, case 2, case 3. (Case 0,1,2 are the "valid" cases.)

; D0 is the case selector variable (byte-sized)

 

default:

 

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program condstr64.s */

.include "../includeARM64.inc"

 

 

=={{header|Action!}}==

INT i

 

FI

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Conditional_structures.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

===if-then-else===

My_Var : Restricted;

 

else

-- do something

===conditional expressions===

Ada 2012 introduces conditional expressions, which are allowed anywhere an expression is allowed (e.g.: in a numeric literal, aggregate, etc.). A conditional expression can either be an if expression or case expression. Conditional expressions must be surrounded by parentheses.

====if expression====

Op : Operation;

Result : Integer;

elsif Op = Divide then

A / B

====case expressions====

Add => A + B,

Subtract => A - B,

Divide => A / B

);

===case with a default alternative===

Today : Days;

 

when others =>

Accumulate_Sales;

 

===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.

 

when Monday =>

Compute_Starting_Balance;

Accumulate_Sales;

-- ignore Saturday and Sunday

 

 

when Saturday | Sunday =>

null; -- don't do anything, if Today is Saturday or Sunday

when Tuesday .. Thursday =>

Accumulate_Sales;

 

===select===

 

====Conditional Accept====

accept first_entry;

-- do something

-- do something

or terminate;

 

====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.

My_Task.Start;

or

delay Timeout_Period;

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.

=={{header|Aikido}}==

===Conditional Expressions===

var x = loggedin ? sessionid : -1

 

 

===if..elif..else===

if (value > 40) {

println ("OK")

println ("RETRY")

}

 

===switch===

switch (arg) {

case "-d":

println ("RETRY")

}

 

=={{header|Aime}}==

===If-elif-else===

 

// first condition is true...

} elif (c2) {

} else {

// none was true...

 

=={{header|ALGOL 60}}==

'''if''' X=Y '''then''' K:=I

An example:

 

'IF' I<J 'THEN' OUTSTRING(1,'(' : I<J')')

OUTSTRING(1,'(' J=')');

OUTINTEGER(1,J)

Algol 60 has also a switch structure:

declaration::= '''switch''' switch:=list_of labels

statement::= '''goto''' switch[expression]

An example:

...

'GOTO' TARGET(/J/);

L1: OUTSTRING(1,'('AA')');

L2: OUTSTRING(1,'('BB')');

 

=={{header|ALGOL 68}}==

 

=={{header|ALGOL W}}==

integer a, b, c;

 

write( case c - a of ( "one", "two", "three", "four" ) )

 

{{out}}

<pre>

a + b is three

two

</pre>

 

The second and third arguments should be blocks (aka anonymous functions or thunks).

 

if: condition then: {

// condition is true...

// condition is false...

}

 

===IfTrue/IfFalse===

One can also send a message to the boolean objects true and false:

 

condition.ifTrue: { /* condition is true... */ } ifFalse: { /* condition is false... */ }

 

=={{header|AmigaE}}==

'''IF-THEN-ELSE'''

-> if condition is true...

ELSEIF condition2

ELSE

-> if all other conditions are not true...

 

or on one single line:

 

 

'''Ternary IF THEN ELSE'''

 

The IF-THEN-ELSE can be used like ternary operator (?: in C)

 

'''SELECT-CASE'''

 

CASE n1

-> code

DEFAULT

-> no one of the previous case...

 

Another version allows for ranges:

 

CASE n1

-> code

DEFAULT

-> none of previous ones

 

The biggest among n1, n2 and so on, must be not bigger than max_possible_value.

=={{header|Apex}}==

===if-then-else===

foo();

} else if (s == 'Bye World') {

} else {

deusEx();

Java also supports [[wp:Short-circuit_evaluation|short-circuit evaluation]]. So in a conditional like this:

aMethod();

<tt>obj.foo()</tt> will not be executed if <tt>obj != null</tt> returns false. It is possible to have conditionals without short circuit evaluation using the <tt>&</tt> and <tt>|</tt> operators (from [[Bitwise operations]]). So in this conditional:

aMethod();

You will get a null pointer exception if obj is null.

===ternary===

 

 

===switch===

=={{header|AppleScript}}==

===if-then-else===

 

set i to 0

else

return "odd"

 

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

bx lr /* return */

 

 

=={{header|Arturo}}==

===if?-else===

 

 

if? num=2 [

else [

print "something went wrong..."

 

{{out}}

===case-when?===

 

case [num]

when? [<2] -> print [num ": it's less than 2"]

else -> print [num ": the number is too big"]

]

 

{{out}}

 

=={{header|Astro}}==

foo()

elif x == 1:

_ => qux()

 

 

=={{header|AutoHotkey}}==

 

===if, else if, else===

If x

MsgBox, x is %x%

MsgBox, x is %x%

Else

 

===ternary if===

y = 1

var := x > y ? 2 : 3

 

===while (looping if)===

MsgBox, %A_Index% is less than 3

 

=={{header|AutoIt}}==

===If, ElseIf, Else===

statements

...

...

EndIf

===Select Case===

Case <expression>

statement1

...]

EndSelect

===Switch Case===

Case <value> [To <value>] [,<value> [To <value>] ...]

statement1

...]

EndSwitch

--[[User:BugFix|BugFix]] ([[User talk:BugFix|talk]]) 15:39, 13 November 2013 (UTC)

 

=={{header|Avail}}==

===If-Then-Else===

 

If someNumber > 5 then [Print: "Too high!";] else [Print: "Adequate amount.";];

else [score := 45;];

 

 

===Ternary===

The basic control structures in Avail can be used as expressions by using blocks with a return value. By tradition this distinction is noted by using a lowercase first character.

 

=={{header|AWK}}==

Conditionals in awk are modelled after C:

For a branch with more than a single statement, this needs braces:

if(i<0) {

i=0; j=1

} else {

i=42; j=2

There is also the ternary conditional:

 

=={{header|Axe}}==

 

===Simple===

YEP()

 

===Inverse If===

NOPE()

 

===If-Else===

YEP()

Else

NOPE()

 

Axe has no support for switch-like statements. If-ElseIf-Else structures are required to achieve the same goal.

 

===If-ElseIf-Else===

NOPE()

ElseIf 1=1

Else

NOPE()

 

===If-InverseElseIf-Else===

NOPE()

Else!If 1=2

Else

NOPE()

 

=={{header|Babel}}==

===Simple select===

 

"foo" "bar" 3 4 > sel <<

 

Prints "foo" since '3 4 >' evaluates to false, which causes sel to remove "bar" from the stack.

===If-Then-Else===

 

{3 4 >}

{"foo"}

ifte

<<

 

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===

 

({3 4 >} {"Three is greater than four" }

{3 3 >} {"Three is greater than three"}

cond

<<

 

Prints "Three is greater than two", as expected.

BASIC can use the if statement to perform conditional operations:

 

20 IF A% THEN PRINT "A IS TRUE"

30 WE CAN OF COURSE USE EXPRESSIONS

50 IF NOT(A%) THEN PRINT "A IS FALSE"

60 REM SOME VERSIONS OF BASIC PROVIDE AN ELSE KEYWORD

 

Here are code snippets from a more modern variant that does not need line numbers:

Single line IF does not require END IF

 

 

Multi-line IF:

 

'do stuff

ELSE IF x = 0 THEN

ELSE

'do more stuff

 

Like in [[#C|C]], any non-zero value is interpreted as True:

 

'the number is not 0

ELSE

'the number is 0

 

===select case===

The condition in each case branch can be one or more constants or variables, a range or an expression.

 

CASE 1

'do stuff

CASE ELSE

'default case

 

===Computed ON-GOTO===

or:

 

20 GOTO v * 100

99 STOP

210 STOP

300 PRINT "Cherry"

 

===Conditional loops===

Some variants of basic support conditional loops:

 

20 L=0

30 WHILE L<5

100 PRINT L

110 L=L+1

 

=={{header|BASIC256}}==

</pre>

I think this test shows that nested if statements parse as they do in c.

for i = 0 to 1

for j = 0 to 1

next j

next i

 

=={{header|Batch File}}==

IF syntax:

IF [NOT] ERRORLEVEL number command

IF [NOT] string1==string2 command

GEQ - greater than or equal

/I case insensitive string compares

The ELSE clause must be on the same line as the command after the IF.

For example:

IF EXIST %filename% (

del %filename%

echo %filename% not found

)

 

=={{header|BBC BASIC}}==

IF condition% THEN statements ELSE statements

 

 

REM ON ... PROC (ELSE clause is optional):

 

=={{header|beeswax}}==

 

The 4 conditional operators are:

' 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.

 

Example:

>`n > 0`d >`m > 0`d >Lp`m > n`;

 

Example output:

i3

n > 0

Enter integer m:

i0

 

=={{header|Befunge}}==

These snippets input a number and use the conditional operators to print a "0" if it is zero and an "X" otherwise.

 

> & |

 

'''#''' is the skip command.

It unconditionally skips one character, allowing a little flexibility in flow control.

 

 

=={{header|blz}}==

===if-else===

if i % 2 == 0

print("even")

print("odd")

end

 

=={{header|Bori}}==

===if-elif-else===

if (i == 0)

return "zero";

else

return "even";

 

=={{header|BQN}}==

The basic method of control flow in BQN is implemented using first-class functions and Choose (<code>◶</code>). Using Choose, we can implement some basic control structures:

IfElse ← {c‿T‿F: c◶F‿T@}

While ← {𝕩{𝔽⍟𝔾∘𝔽_𝕣_𝔾∘𝔽⍟𝔾𝕩}𝕨@}´ # While 1‿{... to run forever

Select ← {(⊑𝕩)◶(1↓𝕩)@}

Switch ← {c←⊑𝕩 ⋄ m‿a←<˘⍉∘‿2⥊1↓𝕩 ⋄ (⊑a⊐C)◶m@}

 

The other method of branching is using function predicates, which can be used in any blocks for an if-else like conditional:

a<b ? a+↩1 ; # If

a<c ? c-↩1 ; # Else If

a-↩2 # Else

 

However, they act like any other block header, so the variables defined in each predicate segment do not exist in their else and else if condition. Block Headers in general provide a rudimentary form of control flow (checking for exact matches and wildcards), but these are much more constrained than a general conditional.

The following expression writes "That's what I thought." to your screen and evaluates to the expression "Right".

 

& put$"Strange, must check that Bracmat interpreter."

& 0

| put$"That's what I thought."

 

=== switch-like branching ===

In the following example, the resulting expression is a single node containing "4".

 

: ( (<3|>5)

& put$"Not quite, must check that Bracmat interpreter."

& put$"That's what I thought."

)

 

=={{header|Brainf***}}==

Thus in the following sequence:

 

 

The . instruction will be skipped, while the following sequence

 

 

will result in an infinite loop. Finally, in the following sequence

 

 

The . instruction will be executed once.

Using the ''Choose'' command:

 

blsq ) 9 2.%{"Odd""Even"}ch

"Odd"

 

Using the ''If'' command (produce next even number if odd):

 

blsq ) 9^^2.%{+.}if

10

blsq ) 10^^2.%{+.}if

10

 

Using the ''IfThenElse'' command (produce next odd number if even or previous even number if odd):

 

blsq ) 10^^2.%{-.}\/{+.}\/ie

11

blsq ) 9^^2.%{-.}\/{+.}\/ie

8

 

Emulating Switch-Case behaviour:

 

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"

 

=={{header|C}}==

===if-elseif-else===

 

{

// Some Task

{

// Some Task

 

===Ternary===

 

 

===switch===

 

{

case 1:

// Some task

break;

 

If fall through algorithms are required use the goto keyword.

 

{

case 1:

// Some task

break;

 

=={{header|C++}}==

Selecting a type depending on a compile time condition

 

 

template<typename ThenType, typename ElseType> struct ifthenelse<true, ThenType, ElseType>

long int, // in that case, we'll need a long int

int> // otherwise an int will do

 

=={{header|Clean}}==

There are no ''then'' or ''else'' keyword in Clean.

The second argument of <tt>if</tt> is the then-part, the third argument is the else-part.

 

===case-of===

42 -> "Correct"

 

===function alternatives===

 

===guards===

| x == 42 = True

| otherwise = False

n | n < 0 -> "Not even close"

42 -> "Correct"

 

=={{header|Clipper}}==

'''if-elseif-else-endif'''

SomeFunc1()

ELSEIF x == 2

ELSE

SomeFunc()

 

'''do case'''

CASE x == 1

SomeFunc1()

OTHERWISE

SomeFunc()

 

=={{header|Clojure}}==

===if-then-else===

 

(if (= 1 2) :yes :no) ; returns :no

 

 

===when===

Similar to if, but body in an implicit do block allowing multiple statements.

No facility for providing an else. <code>when</code> is defined as a macro.

(print "hello")

(println " world")

 

===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.

(= 1 2) :no) ; returns nil

 

(cond

(= 1 2) :no

Since non-nil objects are logical true, by convention the keyword :else is used to yield a default result.

(= 1 2) :no

 

===condp===

Similar to cond, but useful when each test differs by only one variant.

4 :a ; cond equivalent would be (< 4 3) :a

3 :b

2 :c

Optionally takes a final arg to be used as the default result if none of the tests match.

4 :a

3 :b

 

===case===

{{Works with|Clojure|1.2}}

0 (println "0")

1 (println "1")

 

=={{header|CMake}}==

 

if(num GREATER 100)

message("${num} is small.")

message("We might want a bigger number.")

 

The if() and elseif() commands evaluate boolean expressions like ''num GREATER 100''; refer to [http://www.cmake.org/cmake/help/cmake-2-8-docs.html#command:if cmake --help-command if].

=={{header|COBOL}}==

===if-then-else===

imperative-statement-1

else

imperative-statement-2

end-if

 

===evaluate===

when 'good'

good-imperative-statement

when other

default-imperative-statement

 

=={{header|CoffeeScript}}==

===if-then-else===

 

if n == 1

console.log "one"

else

console.log "other"

 

===switch===

 

 

switch n

else

console.log "other"

 

===ternary expressions===

CoffeeScript is very expression-oriented, so you can assign the "result" of an if-then to a variable.

 

 

# alternate form

if condition

then "yup"

 

=={{header|ColdFusion}}==

===if-elseif-else===

'''Compiler:''' [[ColdFusion]] any version

do something

<cfelseif x eq 4>

<cfelse>

do something else

 

===switch===

'''Compiler:''' [[ColdFusion]] any version

<cfcase value="1">

do something

do something

</cfdefaultcase>

 

=={{header|Comal}}==

===IF/THEN===

 

===IF/THEN/ELSE===

PRINT "True"

ELSE

PRINT "False"

 

===IF/THEN/ELIF/ELSE===

PRINT "One"

ELIF choice=2 THEN

PRINT "Two"

ELSE

 

===CASE/WHEN===

CASE choice OF

WHEN 1

PRINT "Some other choice"

ENDCASE

 

=={{header|Common Lisp}}==

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.

 

"That is the answer to life, the universe and everything"

 

==== <code>when</code> and <code>unless</code> ====

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.

 

((and (> val 3) (< val 6)) (print "yes"))

((> val 99) (print "too far"))

 

=={{header|Computer/zero Assembly}}==

===if-elseif-else===

 

{

// Some Task

{

// Some Task

 

===Ternary===

 

// if condition is true var will be set to 1, else false.

int var = condition ? 1 : 2;

 

=={{header|D}}==

:''See [[Conditional Structures#C|C]], sans the preprocessor.''

 

enum int i = 5;

 

// default: // Forbidden in final switches.

}

 

=={{header|Dao}}==

===If Elif Else===

if( a == 1 ){

io.writeln( 'a == 1' )

}else{

io.writeln( 'a is neither 1 nor 3' )

 

===Switch Case===

switch( a ){

case 0: io.writeln( 'case 0' )

case 3, 4, 5: io.writeln( 'case 3,4,5' )

default: io.writeln( 'default' )

 

=={{header|Delphi}}==

=={{header|Deluge}}==

 

sVar = "good";

} else if (input.Field == "Bye World") {

} else {

sVar = "neutral";

 

=={{header|DM}}==

===if-elseif-else===

// Do thing, DM uses indentation for control flow.

 

else

// Do thing

 

===Ternary===

var/x = condition ? 1 : 2

 

===Switch===

if (0)

// Do thing if zero

else

// Fallback if nothing was matched.

 

=={{header|Dragon}}==

===if-then-else===

{

add()

{

both()

 

=={{header|DWScript}}==

 

=={{header|Déjà Vu}}==

pass

elseif b:

pass

else: # c, maybe?

 

=={{header|E}}==

===if-then-else===

 

println("okay")

} else if (!okay) {

} else {

println("not my day")

 

The pick/2 message of booleans provides a value-based conditional:

 

 

It can therefore be used to construct a Smalltalk-style conditional:

 

println("okay")

}, fn {

println("not okay")

 

All of the above conditionals are expressions and have a usable return value.

E's "switch" allows pattern matching.

 

 

def value := switch (expression) {

match [`*`, [a, b]] { a * b }

match [op, _] { throw(`unknown operator: $op`) }

 

=={{header|EasyLang}}==

if i mod 2 = 0

elif i mod 3 = 0

else

 

=={{header|Efene}}==

Since if and case do pattern matching, if an if or case expression don't match some of the patterns, the program will crash

 

show_if_with_parenthesis = fn (Num) {

if (Num == 1) {

show_switch_with_parenthesis(random.uniform(3))

show_switch_without_parenthesis(random.uniform(3))

 

=={{header|Ela}}==

===if-then-else===

 

 

===Guards===

 

 

===Pattern matching===

 

 

===match expression===

 

x::xs = x :: force xs

 

=={{header|Erlang}}==

case expressions take an expression and match it to a pattern with optional guards.

 

{N,M} when N > M -> M;

{N,M} when N < M -> N;

_ -> equal

 

===if===

Guards must evaluate to true or false so true is the catch-all clause.

 

if

N > M -> M;

N < M -> N;

true -> equal

 

===Function Clauses===

Functions can have multiple clauses tested in order.

 

test({N,M}) when N < M -> N;

 

=={{header|F_Sharp|F#}}==

printfn "%s" (if 3<2 then "3 is less than 2" else "3 is not less than 2")

{{out}}

<pre>

===?===

? is for when you don't need branching, but only need to select between two different values.

t 1 2 ? ! returns 1

 

===if===

 

===cond===

 

===case===

 

===when===

 

===unless===

 

=={{header|FALSE}}==

Because there is no "else", you need to stash the condition if you want the same effect:

or

 

=={{header|Fancy}}==

 

===if:then:===

"x < y!" println # will only execute this block if x < y

}

 

===if:then:else::===

"x < y!" println # will only execute this block if x < y

} else: {

"x not < y!" println

}

 

 

===if_true:===

"x < y!" println # will only execute this block if x < y

}

 

===if_false: / if_nil:===

"x not < y!" println # will only execute this block if x >= y

}

 

===if_true:else:===

"x < y!" println

} else: {

"x >= y!" println

}

 

===if_false:else:===

"x >= y!"

} else: {

"x < y!" println

}

 

===if:===

 

 

===unless:===

 

=={{header|Forth}}==

===IF-ELSE===

example:

 

===CASE-OF===

( integer ) OF ( statements ) ENDOF

( integer ) OF ( statements ) ENDOF

( default instructions )

example: a simple CASE selection

CASE

0 OF ." Zero!" ENDOF

1 OF ." One!" ENDOF

." Some other number!"

 

===Execution vector===

To obtain the efficiency of a C switch statement for enumerations, one needs to construct one's own execution vector.

CREATE ( default-xt [count-xts] count -- ) DUP , 0 DO , LOOP ,

DOES> ( u -- ) TUCK @ MIN 1+ CELLS + @ EXECUTE ;

 

8 digit \ eight

===Execution Vector 2===

This method was used by the late Jim Kalihan and Dr. Julian Nobel

 

\ lookup execution token and compile

 

\ Usage: 3 SELECT

 

=={{header|Fortran}}==

===IF-THEN-ELSE===

ANSI FORTRAN 77 or later has an IF-THEN-ELSE structure:

q = q + a**2

else if ( a .ge. 0.0 ) then

else

q = q - a

 

===SELECT-CASE===

ISO Fortran 90 or later has a SELECT-CASE structure:

case (21:) ! matches all integers greater than 20

q = q + i**2

case default ! matches all other integers (negative in this particular case)

q = q - I

 

===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.

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 ! sink/source, does not change

anew(1:n,1:m) = a(1:n,1:m)

 

=={{header|FreeBASIC}}==

===IF-ELSEIF-ELSE-END IF===

If a = 1 Then

sub1

Else

sub3

 

===SELECT-CASE===

Select Case a

Case 1

Case Else

sub3

 

===IFF===

 

===ON-GOTO===

 

===IF-GOTO (deprecated)===

 

===ON-GOSUB (legacy dialects only)===

 

===#IF-#ELSEIF-#ELSE-#ENDIF (preprocessor)===

#IF (WORDSIZE = 16)

' Do some some 16 bit stuff

#ELSE

#ERROR WORDSIZE must be set to 16 or 32

 

===#IFDEF (preprocessor)===

#IFDEF _DEBUG

' Special statements for debugging

 

===#IFNDEF (preprocessor)===

#DEFINE _DEBUG

 

=={{header|friendly interactive shell}}==

===if-then-else===

if test $var = 'Hello World'

echo 'Welcome.'

else

echo 'Huh?'

 

===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.

case az

echo The word is "az".

case '*'

echo Neither begins with a or ends with z.

 

=={{header|Futhark}}==

Futhark supports branching with a syntax common to most functional languages.

 

if <condition> then <truebranch> else <falsebranch>

 

=={{header|GAP}}==

=== if-then-else ===

<statements>

elif <condition> then

else

<statements>

 

=={{header|Go}}==

===If===

Simplest usage is,

statements

The braces are required, even around a single statement.

statements

} else {

other

statements

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,

statements

} else if booleanExpression2 {

otherStatements

}

If allows a statement to be included ahead of the condition. This is commonly a short variable declaration, as in,

DoPos(x)

} else {

DoNeg(x)

In this case the scope of x is limited to if statement.

 

===Switch===

Simple usage is,

case booleanExpression1:

statements

resort

statements

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,

case value1:

statements

other

statements

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:

case x == "cheese":

statements

other

statements

Also, as with if, the scope of x is limited to the switch statement.

 

 

An interesting example:

case booleanExpression1:

default:

other

statements

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.

switch {

case true:

}

fmt.Println("I want out!")

Labels provide the desired capability. The following prints "I'm off!"

switch {

case true:

}

}

 

=={{header|Harbour}}==

'''if-elseif-else-endif'''

SomeFunc1()

ELSEIF x == 2

ELSE

SomeFunc()

 

'''do case'''

CASE x == 1

SomeFunc1()

OTHERWISE

SomeFunc()

 

'''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.

CASE 1

SomeFunc1()

OTHERWISE

SomeFunc()

 

=={{header|Haskell}}==

 

===if-then-else===

1

 

===Guards===

===Pattern matching===

===case statement===

 

=={{header|HicEst}}==

 

IF( a >= b ) THEN

ELSE

WRITE(StatusBar) a, b, some_string

 

=={{header|HPPPL}}==

=== IF ===

Note that X has to be a number; else a runtime error occurs.

// do if X is not 0

ELSE

// do if X is 0

=== CASE ===

IF X == 1 THEN

// do stuff if X equals 1

DEFAULT

// do other stuff

 

=={{header|i}}==

software {

a = 3

print("a = ", a)

end

 

=={{header|Icon}} and {{header|Unicon}}==

===if-then-else===

The control structure evaluates expr1 if expr0 succeeds and expr2 if it fails.

expr1

else

===case-of===

The first successful selection expression will select and evaluate the specific case.

expr1 : expr2

expr3 : expr4

default: expr5

Note that expr1 and expr3 are expressions and not constants and it is possible to write expressions such as:

f(x) | g(x) : expr2

s(x) & t(x) : expr4

default: expr5

===Compound expressions (blocks)===

In the examples below, multiple expressions can be grouped as in:

expr1

expr2

expr3

Which is equivalent to this:

For example the following, which will write 4, looks strange but is valid:

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.

===Conjunction===

Conjunctions yeild the value of the final expression provided all the previous expressions succeed.

Alternately, conjunction can be written thus:

===Conjunction, yielding a different result===

The alternate form of conjunction can be modified to produce a different result (other than the last)

For example:

Yields the value of expr2 if all of the expressions succeed.

<br>A more complicated example showing non-constant expressions:

Note: if expr0 yields a value of type 'procedure' or 'string' the appropriate procedure (or operator) is invoked.

 

Basic if/then:

 

 

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:

 

... some code here ...

endif [else begin

... some other code here ...

 

===case===

 

(choice-1): <command-1>

[(choice-2): <command-2> [...]]

[else: <command-else>]

 

(Or replace any of the commands with {begin..end} pairs)

===switch===

 

(choice-1): <command-1>

[(choice-2): <command-2> [...]]

[else: <command-else>]

 

The <tt>switch</tt> will execute all commands starting with the matching result, while the <tt>case</tt> will only execute the matching one.

===on_error===

 

 

Will resume execution at label when an error is encountered. <tt>on_ioerror</tt> is similar but for IO errors.

=={{header|Inform 7}}==

===if-then-else===

if N is 1, say "one.";

otherwise say "not one.";

 

[short and long forms can be negated with "unless"]

 

===switch===

-- 1: say "one.";

-- 2: say "two.";

 

===if-then-else in text===

 

===other branching text substitutions===

Text that may be printed multiple times can also use sequential and random branching:

say "[one of]red[or]blue[or]green[at random].";

 

 

[only appears once]

 

===rulebook approach===

Conditional logic may also be expressed in the form of a rulebook, with conditions on each rule:

 

 

Number handling is a number based rulebook with default success.

follow the number handling rules for 2;

follow the number handling rules for 4;

 

=={{header|Isabelle}}==

imports Main

begin

lemma "recurse n = 0" by(induction n) simp+

 

 

=={{header|J}}==

See [[Conditional Structures/J]]

 

=={{header|Java}}==

===if-then-else===

foo();

deusEx();

Java also supports [[wp:Short-circuit_evaluation|short-circuit evaluation]]. So in a conditional like this:

aMethod();

<tt>obj.foo()</tt> will not be executed if <tt>obj != null</tt> returns false. It is possible to have conditionals without short circuit evaluation using the <tt>&</tt> and <tt>|</tt> operators (from [[Bitwise operations]]). So in this conditional:

aMethod();

===ternary===

 

===switch===

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.

 

foo();

bar();

foobar();

foobar();

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

 

=={{header|JavaScript}}==

===if-then-else===

 

foo();

} else if( s == "Bye World" ) {

} else {

deusEx();

 

===switch===

 

case 1:

one();

default:

everythingElse();

 

===conditional (ternary) operator (?:)===

 

 

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.

 

'use strict';

var varHead = lst.length ? lst[0] : null;

) : []

) : [];

 

=={{header|JCL}}==

</pre>

The syntax of COND parameter of the EXEC statement is :

It is a condition to bypass a job step, and it can be translateted into :

Example:

<pre>

if 0 ne STEP3.rc then skip step STEP6

</pre>

The conditions can be multiple :

Means:

Example:

<pre>

if 4 le STEP1.rc or 8 le STEP3.rc then skip step STEP6

===if-then-else===

 

print(Template("""{% for lang in ["Jinja", "Python", "Swift", "Nim"] %}

{{ loop.index }}) {{ lang }}{% if loop.last %}.{% else %},{% endif %}

{%- endfor %}""").render())

 

===ternary expressions===

 

print(Template("""{% for lang in ["Jinja", "Python", "Swift", "Nim"] %}

{{ loop.index }}) {{ lang }}{{ "." if loop.last else "," }}

{%- endfor %}""").render())

 

===short-circuit evaluation===

 

print(Template("""{% for lang in ["Jinja", "Python", "Swift", "Nim"] %}

{{ loop.index }}) {{ lang }}{{ loop.last and "." or "," }}

{%- endfor %}""").render())

 

=={{header|jq}}==

# 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:

if cond then f elif cond1 then f1 .... else g end

 

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

 

exp

| if . == true then "true"

elif type == "string" then .

else error("unexpected value: \(.)")

Since jq's <tt>and</tt> and <tt>or</tt> are short-circuiting, they can also be used for branching, as can the binary disjunctive operator `//`.

 

Note: this documentation is mostly copied from the Julia 0.6.0 documentation at: https://docs.julialang.org/en/stable/manual/control-flow/#man-conditional-evaluation-1

<h3>Conditional Evaluation</h3>

function test(x, y)

if x < y

julia> test(1, 1)

x is equal to y

<p>

The elseif and else blocks are optional, and as many elseif blocks as desired can be used. The condition expressions in the if-elseif-else construct are evaluated until the first one evaluates to true, after which the associated block is evaluated, and no further condition expressions or blocks are evaluated.

</p><p>

The so-called "ternary operator", ?:, is closely related to the if-elseif-else syntax, but is used where a conditional choice between single expression values is required, as opposed to conditional execution of longer blocks of code. It gets its name from being the only operator in most languages taking three operands:

a ? b : c

<p>

The expression a, before the ?, is a condition expression, and the ternary operation evaluates the expression b, before the :, if the condition a is true or the expression c, after the :, if it is false. To facilitate chaining, the operator associates from right to left.

=={{header|Kabap}}==

Kabap supports the '''if''' statement and a range of standard comparators. Truthiness is considered anything not "0" or 0.

if 1;

$result = "Execute";

}

 

 

=={{header|Keg}}==

Keg supports if statements like this:

Usually the ending proprotions may be omitted:

 

Also Keg supports (though not intentionally) a form of short-circuit evaluation:

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

}

println("$i is $t")

Sample input/output (program invoked without arguments):

{{out}}

 

=={{header|Lambdatalk}}==

{if true then yes else no}

-> yes

{switch 0}

-> 0 is zero

 

=={{header|langur}}==

 

In the shortened forms, you dispense with the keywords (except the first one).

===if expressions===

If expressions are scoped per section.

...

} else if .x > 0 {

val .y = 70

...

 

===shortened form if expression===

This is more flexible than a ternary operator, as it allows more than one test. An else section is optional (null by default).

 

 

 

 

 

 

case true: ...

# all are true

case _, null, true: ...

# .y == null and .z == true

 

 

===implicit fallthrough===

case true:

# implicit fallthrough

# no fallthrough

default: 1

 

===explicit fallthrough from anywhere===

case true:

if .y > 100 {

}

case false: ...

 

_, >= .z: ...; # .y >= .z

 

=={{header|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.

; branch if (result < 0 || result == 0 || result > 0)

; ^ this is always true

 

; or any combination of these condition codes, e.g.

The effect of <tt>if (x == y) { go to LABEL }</tt> is achieved by adding <tt>x</tt> to <tt>-y</tt> (the two's complements of <tt>y</tt>) and branching if the result is zero. The following example prints "Branch Taken!" because the values of <tt>x</tt> and <tt>y</tt> are both 1.

LD R1, x ; get x

LD R2, y ; get y

taken .stringz "Branch Taken!"

nottaken .stringz "Branch Not Taken!"

 

=={{header|LIL}}==

LIL sports '''if''' with an optional code block for else conditions.

 

 

These can of course be nested in clear or nasty forms. '''if''' blocks can contain '''if''' blocks with as many optional else clauses as a programmer sees fit to intermingle.

{{works with|Lisaac|0.13.1}}

===if-then-else===

 

n := 3;

} else {

IO.put_string "n is none of the above\n";

===when===

 

n := 3;

.when 4 then {

"n is 4\n".print;

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.

=={{header|Little}}==

 

 

// if-then-else

default:

puts("is neither");

 

=={{header|Logo}}==

 

[[UCB Logo]] and its descendants have also case:

output case :letter [ [[a e i o u] "true] [else "false] ]

end

show vowel? "e

{{out}}

Logo also provides TEST which is local to a procedure:

test :arg1 = :arg2

iftrue [print [Arguments are equal]]

iffalse [print [Arguments are not equal]]

 

=={{header|LSE}}==

==={{header|SI..ALORS..SINON..FIN SI}}===

AFFICHER [4X, 'A ET B = .VRAI.',/]

SINON

SINON

AFFICHER [4X, 'A ET QUE B = .FAUX.',/]

 

==={{header|EVALUER}}===

QUAND 0

AFFICHER [4X,'QUAND X=0',/]

QUAND AUTRE

AFFICHER [4X,'QUAND X est autre, X=',U,/] X

 

==={{header|SELON..ALLER EN..}}===

1 AFFICHER [8X,U,X,/] '0 VACHES'

2 AFFICHER [8X,U,/] '1 MOUTONS'

10 AFFICHER [U,/] 'Vous avez choisi VACHES!'

15 TERMINER

 

==={{header|SI..ALORS..SINON..IS}}===

 

==={{header|SELON..DANS..SINON..FIN}}===

 

=={{header|LSE64}}==

The simple conditionals take single words rather than blocks of statements, as in most other languages.

f : " false" ,t

true if t

false ifnot f

 

Cascading conditionals are constructed using duplicate definitions and "then", yielding a syntax reminiscent of functional language [[Pattern Matching]].

onetwo : dup 2 = then " Two" ,t

 

Short-circuit operators "&&" and "||" are used for complex conditionals.

 

=={{header|Lua}}==

--if-then-elseif-then-else

if a then

}

 

 

=={{header|Luna}}==

 

===if-then-else===

''(see: [https://github.com/luna/luna/issues/125#issuecomment-365683922 github/luna #125])''

 

===case-of===

...

def asText: case self of:

JSONString t: t

 

''(see: [https://github.com/luna/luna/blob/77b1d974cb07528e9f195dd47e177dd497560da1/stdlib/Std/src/Base.luna#L1047-L1050 Std.JSON])''

=={{header|M2000 Interpreter}}==

===If Then Else.if Else===

Module CheckIt {

Read a

CheckIt 0

CheckIt -100

 

===IF() and IF$() - Ternary===

One expression evaluated only. We can use If$() to use string expressions

Module Checkit {

Read x

Checkit 3, 20

 

 

Ternary can used as Elvis operator (a function here), when a false (or a Nothing, for some kind of objects) evaluated then return something after ->, else return true or the object so if A is object then If(A->,B) return A.

 

 

Module Checkit {

def a

}

Checkit

 

===Select Case===

We can use string, and three types of cases (all of them in one case), >1000, 10 to 40, 400

Module CheckIt {

Read a

CheckIt -500

 

 

===Conditional loops===

x=10

While x>0 {

Until x=10

 

 

===On Goto, On Gosub===

Module CheckIt {

For i=1 to 10 {

CheckIt

 

===If Then line No /label===

Line numbers are optional and can be in any order, but from start in current block, and if not found then replaced with exit, until search can't continue (at modules/function bounds, we can't jump out of a module or function).

 

a$="123"

if a$ ~ "12*" then 1000

1000 Print "ok final"

Goto alfa

 

We can jump out of a sub, but we have to use Return to adjust the return stack.Wehn found Sub interpreter execute Exit statement so no need for End or Exit before sub beta()

We can call beta() using Gosub beta() (not Call, call is for modules and functions). If we have an array beta() then we must use Gosub beta() because interpreter prefer arrays, and raise error "missing ="

 

Module Checkit {

Rem : Dim beta(10) ' remove Rem to get error when call beta() without Gosub

Checkit

 

 

=={{header|Make}}==

An if condition using pure make (no gmake extensions)

C=0

 

 

false:

 

Using it

> was false.

 

make -f do.mk if C=1

 

With out using recursion but letting make continue with non-failed

targets even when some of the targets failed (-k)

 

if: true false

false:

@expr $(C) >/dev/null && exit 1 || exit 0

 

Invoking it. Note the use of -k which allows make to evaluate subsequent

targets even when a previous non-related target failed.

was true.

*** Error code 1

|make -f do.mk -s -k C=0

*** Error code 1

 

Using gmake

 

B=

 

 

do:

 

Using it

1 .. true

|gmake -f if.mk A=0

 

=={{header|Maple}}==

=== Conditional statements ===

Example syntax for conditional statements:

res := x;

else

res := -x;

 

Example syntax for conditional statements with else-if:

res := y;

elif y = 0 then

else

res := sqrt(x^2+y^2);

 

=== Conditional functions ===

===If statements===

Example:

disp 'x==1';

elseif x > 1

else

disp 'x<1';

===Switch statements===

Example:

case 1

disp 'Hello';

otherwise

disp 'Skynet Active';

 

=={{header|Maxima}}==

 

=={{header|MAXScript}}==

===if===

(

print "one"

(

print "Neither one or two"

 

===case===

'''Form one'''

(

1: (print "one")

2: (print "two")

default: (print "Neither one or two")

'''Form two'''

(

(x == 1): (print "one")

(x == 2): (print "two")

default: (print "Neither one or two")

 

=={{header|MBS}}==

 

x:=0;

IF x = 1 THEN

ELSE

! Do something else

 

=={{header|MDL}}==

An "else" part is traditionally implemented as a final clause whose first element is an atom, like <code>T</code>, since atoms always evaluate to themselves and are always true.

 

(<==? .X 2> <PRINC "two">)

 

===AND and OR===

These short-circuiting boolean functions can also be used as simple conditionals.

 

<AND <L? .X 0> <SET X <- .X>>>

 

;"Print a message unless the quiet flag is set"

 

=={{header|Metafont}}==

 

% do something

elseif conditionB:

else:

% do this

 

The particularity of <tt>if</tt> construct in Metafont is that it can be part of an expression, and the "do something" <cite>does not need to fit into the syntactic structure</cite>. E.g. we can write something like

 

 

Alone, the code <tt>3 +</tt> does not mean anything; but once the condition is evaluated, the whole expression must become "correct"; e.g. if <tt>a > 5</tt>, the expression will be

=={{header|min}}==

{{works with|min|0.19.6}}

; evaluate second quotation.

; Otherwise, evaluate the third.

((3 <) ("Smaller than 3" puts!)) ; quotation if the first quotation

((true) ("Exactly 3" puts!)) ; evaluates to true. Otherwise, move

 

=={{header|MiniScript}}==

MiniScript supports if/else-if/else, with arbitrary number of else-if sections when in block form:

 

if x < 10 then

print "small"

else

print "just right"

 

It also supports single-line if or if/else statements (though no else-if sections are permitted in this case):

 

 

Finally, like many other languages, MiniScript uses short-circuit evaluation, a form of implicit branching where the rest of a boolean expression is not evaluated at all if the truth value can already be determined.

 

print "checking smallness"

return x < 40

end function

 

 

{{out}}

<pre>checking smallness</pre>

 

=={{header|МК-61/52}}==

Conditional jumps are done by four instructions, comparing the register X with zero:

 

x#0 XX

x>=0 XX

 

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

=={{header|Modula-2}}==

===if-then-else===

InOut.WriteString('One')

ELSIF i = 2 THEN

ELSE

InOut.WriteString('Other')

 

===Case===

1 : InOut.WriteString('One')

| 2 : InOut.WriteString('Two')

ELSE

InOut.WriteString('Other')

 

=={{header|Modula-3}}==

===if-then-else===

Bar();

ELSE

Baz();

 

Bar();

ELSIF Foo = "bar" THEN

ELSE

Zeepf();

 

===Case===

| 1 => IO.Put("One\n");

| 2 => IO.Put("Two\n");

ELSE

IO.Put("Something\n");

===Type-case===

<tt>TYPECASE</tt> is used on reference types to perform different operations, depending on what it is a reference to.

| NULL => IO.Put("Null\n");

| CHAR => IO.Put("Char\n");

ELSE

IO.Put("Something\n");

 

=={{header|Monicelli}}==

Monicelli has a single conditional structure that covers both if/then/else and switch/case

che cosè var? # switch var

minore di 0: # case var < 0

...

e velocità di esecuzione

 

=={{header|Morfa}}==

===if-then-else===

if(s == "Hello World")

{

baz();

}

Morfa supports [[wp:Short-circuit_evaluation|short-circuit evaluation]], so <tt>obj.foo()</tt> won't be executed if <tt>obj</tt> is null:

if(obj isnt null and obj.foo())

doSomething();

 

===ternary===

var t = if(s == "Hello World") foo() else bar();

 

===switch===

There is no fallthrough, <tt>break</tt> statement does not have any special meaning inside a switch. If the <tt>break</tt> is in a loop then <tt>break</tt> exits that loop, otherwise it is invalid.

switch (num)

{

result = "a lot";

}

 

=={{header|MUMPS}}==

===If / I and ELSE / E===

<p>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:

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:

IF T DO SUBROUTINE IF 1

 

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:

 

IF T DO

. DO SUBROUTINE

 

 

 

===$Select / $S===

<p>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.</p>

 

===(command postconditional i.e. colon/:===

GOTO:ReallyGo LABEL

QUIT:LoopDone

<p>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.</p>

<p>The exceptions are FOR, IF, and ELSE.

=={{header|Nanoquery}}==

===if-then-else===

foo()

else if x = 1

else

boz()

 

=={{header|Nemerle}}==

===if-else===

<tt>if (cond) <then> else <this>;</tt> is an expression in Nemerle, requiring both keywords (<tt>if</tt> and <tt>else</tt>) to be valid. <tt>when</tt> and <tt>unless</tt> are macros for which <this> = null. <tt>cond</tt> must be an expression that evaluates to a bool (true|false), other types aren't automatically assigned truth or falsehood as in some languages.

when (stock.price < buy_order) stock.Buy();

 

===match===

Much cleaner than stacked if-else's, similar in some ways to switch-case (but more flexible). See [http://nemerle.org/wiki/index.php?title=Quick_Guide#Pattern_Matching here], [http://nemerle.org/wiki/index.php?title=Grok_Variants_and_matching#Matching here], or, for extra detail, [http://nemerle.org/wiki/index.php?title=Patterns_%28ref%29 the reference].

{

|1 => "x is one"

|x when (x < 5) => "x is less than five"

|_ => "x is at least five"

 

=={{header|NetRexx}}==

===IF-THEN-ELSE===

if logicalCondition then conditionWasTrue()

else conditionWasFalse()

conditionsWereFalse()

...

 

===SELECT===

 

<tt>OTHERWISE</tt> is optional but may result in run-time errors (<tt>netrexx.lang.NoOtherwiseException</tt>) if it isn't provided.

select

when logicalCondition1 then condition1()

catch ex1 = NoOtherwiseException

ex1.printStackTrace()

 

===SELECT-CASE===

select case cc

when 'A' then say 'the case is A'

when 'B' then say 'the case is B'

otherwise say 'selection not recognized'

 

'''Note:''' This is functionally equivalent to:

when cc == 'A' then ...

when cc == 'B' then ...

 

===SELECT Optional Features===

 

<tt>PROTECT</tt> is used for program concurrency &amp; synchonization in multi-threaded programs.

when 'A' then do

say 'the case is A'

say 'selection done'

say 'TTFN'

 

=={{header|newLISP}}==

===if===

'''Interpreter:''' [[newLISP]] v.9.0

A third expression can be used as an else.

 

=={{header|Nim}}==

===if-then-else===

foo()

elif x == 1:

baz()

else:

 

===case-of===

of 0:

foo()

baz()

else: # All cases must be covered

 

=={{header|Objeck}}==

===if-else===

a := GetValue();

if(a < 5) {

"equal to 5"->PrintLine();

};

 

===select===

a := GetValue();

select(a) {

}

};

 

=={{header|Object Pascal}}==

===if-then-else===

 

 

if condition then

1 (* evaluate something *)

else

 

If-then-else has higher precedence than <tt>;</tt> (the semicolon), so if you want to have multiple statements with side effects inside an "if", you have to enclose it with <tt>begin</tt>...<tt>end</tt> or with parentheses:

 

(); (* evaluate things for side effects *)

5

(); (* evaluate things for side effects *)

42

 

===match-with===

| 0 -> () (* evaluate something *)

| 1 -> () (* evaluate something *)

| n when n mod 2 = 0 -> () (* evaluate something *)

 

The first <tt>|</tt> is optional, and usually omitted.

=={{header|Octave}}==

'''if-then-elseif-else'''

% body

endif

else

% otherwise body

 

'''switch'''

case label1

% code for label1

otherwise

% none of the previous

 

''Labels'' can be numeric or string, or cells to group several possibilities:

 

case 1

disp("it is 1");

otherwise

disp("unknown!");

 

=={{header|Oforth}}==

Conditional structures are :

 

aBoolean ifFalse: [ ... ]

aObject ifNull: [ ... ]

aObject ifNotNull: [ ... ]

 

Each conditional structure consume the object on the top of the stack.

Each conditional structure can be followed by a else block

 

Example :

 

self isPositive

ifTrue: [ self ==0 ifTrue: [ 0 ] else: [ 1 ] ]

 

=={{header|Ol}}==

; ==> if-then: equal

 

; ==> if-then-else: equal

 

 

case, the sequence of comparing values.

(case (* 2 2)

(print "case: 3"))

(print "case: 4"))

(print "case: 5 or 6 or 7"))

(else

(print "case: i don't know")))

; ==> case: 4

 

(['case1 x y]

(print "case: case1 " x ", " y))

(else

(print "case: i don't know")))

 

cond, the sequnce of comparators.

(cond

((= (* 2 2) 4)

(print "cond: i don't know")))

; ==> cond: equal

 

case-lambda, selecting the lambda based on arguments count.

(define smart (case-lambda

((x)

(smart 1 2) ; ==> 1, 2, -

(smart 1 2 3) ; ==> 1, 2, 3

 

=={{header|ooRexx}}==

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,

 

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

 

With this form, the second conditional expression is only evaluated if the first expression is true.

 

===IF THEN --- IF THEN/ELSE===

if y then x=6 /* Y must be either 0 or 1 */

 

else nop

else if z<0 then z=-y

 

===SELECT WHEN===

/*the WHEN conditional operators are the same as */

/*the IF conditional operators. */

/*were satisfiied, a SYNTAX condition is raised (error).*/

end

===SELECT WHEN/OTHERWISE===

select

when a=='angel' then many='host'

exit 13

end

 

=={{header|OxygenBasic}}==

if a then b=c else b=d

 

end select

 

 

=={{header|Oz}}==

===if-then-else===

if {IsEven X} then

{Show even}

{Show 'should not happen'}

end

 

===if-then-else as a ternary operator===

if X > Y then X else Y end

 

===case statement===

case X of 0 then 1

[] _ then X * {Fac X-1}

end

 

=={{header|PARI/GP}}==

GP uses a simple <code>if</code> statement:

and short-circuit <code>&&</code> and <code>||</code> (which can be abbreviated <code>&</code> and <code>|</code> if desired).

 

===if-then-else===

 

procedure1

ELSE

procedure3;

procedure4

 

=== case ===

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.

 

1,4,9: { executed if i is 1, 4 or 9 }

DoSomething;

else

DoYetAnotherThing;

 

Given the variable "X" as a char the following is valid:

 

'A' : statement ;

'B' : statement ;

else

Statement ;

 

=={{header|Perl}}==

===if/else===

 

do_something;

 

 

do_something;

}

else {

do_fallback;

 

do_something;

}

else {

do_fallback;

 

===unless===

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.

 

 

===logical operators===

 

 

 

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

{{works with|Perl|5.10}}

 

given ($input) {

when (0) { print 'input == 0'; }

when (/rats/) { print 'input matches rats'; }

default { do_fallback; }

 

=={{header|Phix}}==

{{libheader|Phix/basics}}

===if===

<span style="color: #000080;font-style:italic;">-- do something</span>

<span style="color: #000080;font-style:italic;">-- do something</span>

<span style="color: #000080;font-style:italic;">-- do something</span>

<span style="color: #008080;">else</span>

<span style="color: #000080;font-style:italic;">-- do something</span>

 

There is no limit to the number of elsif clauses, including 0. The else clause is also optional,

 

===iff===

<span style="color: #000000;">somevar</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">iff<span style="color: #0000FF;">(<span style="color: #000000;">flag<span style="color: #0000FF;">?<span style="color: #000000;">true_expr<span style="color: #0000FF;">:<span style="color: #000000;">false_expr<span style="color: #0000FF;">)

 

In an iff() expression, only one of true_expr or false_expr will be evaluated, not both.

first if statement, and in the second the conditions are evaluated at compile-time and code is only

emitted for one of the branches.

<span style="color: #008080;">constant</span> <span style="color: #000000;">DEBUG<span style="color: #0000FF;">=<span style="color: #004600;">false</span>

<span style="color: #008080;">if</span> <span style="color: #000000;">DEBUG</span> <span style="color: #008080;">then</span>

<span style="color: #7060A8;">puts<span style="color: #0000FF;">(<span style="color: #000000;">1<span style="color: #0000FF;">,<span style="color: #008000;">"this is linux\n"<span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if

 

===switch===

<span style="color: #008080;">switch</span> <span style="color: #000000;">v</span> <span style="color: #000080;font-style:italic;">/*with fallthrough*/</span> <span style="color: #008080;">do</span>

<span style="color: #008080;">case</span> <span style="color: #000000;">1<span style="color: #0000FF;">,<span style="color: #000000;">2<span style="color: #0000FF;">:</span>

<span style="color: #000080;font-style:italic;">-- do something</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">switch

 

By default there is no fallthough on switch clauses, however you can add(/uncomment) a directive, and you can

use them, also have some conditional guards for cross-platform support

 

[32]

mov eax,[var]

syscall

[]

 

=={{header|PHL}}==

If-else:

 

if (a == 5) {

doSomething();

} else {

error();

 

=={{header|PHP}}==

'''Interpreter''': [[PHP]] 3.x, 4.x, 5.x

 

 

$foo = 3;

}

 

 

===switch===

'''Interpreter''': [[PHP]] 3.x & 4.x & 5.x

 

 

switch ($i)

}

 

 

===See Also===

Here are examples of each of these constructs.

 

N = 10,

 

% condition in function head

test_func(N) = "less than 14", N < 14 => true.

 

{{out}}

=={{header|PicoLisp}}==

===Two-way conditions===

(then-do-this) # Then execute the following expression

(else-do-that) # Else execute all other expressions

(then-do-this) # Then execute the following expression

(else-do-that) # Else execute all other expressions

One-way conditions

(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

===Four-way condition===

(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

===Multiple conditions===

((condition1) # If this condition evaluates to non-NIL

(expression 1) # Execute these expression(s)

(NIL # If none evaluated to NIL

(expression 1) # Execute these expression(s)

 

===Selection===

(value1 # If it is equal to, or member of, 'value1'

(do-this1) # Execute these expression(s)

(do-that2) )

(T # Else execute final expression(s)

 

=={{header|PL/I}}==

===if-then-else===

 

if condition_exp then

else do;

list_of_statements;

 

So a cascading form can be derived from:

statement_1;

else if condition_exp2 then

else do;

list_of_statements;

 

=== case ===

 

==== select - format 1 ====

when (1,4,9)

do;

statement_s;

end;

 

==== select - format 2 ====

when (i = 4)

do;

statement_s;

end;

 

Notes:

=={{header|PL/M}}==

IF-THEN-ELSE:

IF COND THEN STATEMENT1; ELSE STATEMENT2;

 

ELSE IF CONB2 THEN STATEMENT2;

ELSE IF CONB3 THEN STATEMENT3;

 

DO-CASE:

/* DEPENDING ON WHETHER EXPR EVALUATES TO 0, 1, ... */

/* EXPR MUST BE IN RANGE OR THE PROGRAM WILL JUMP TO HYPERSPACE */

STATEMENT1;

...

 

=={{header|Pop11}}==

The simplest conditional is:

 

;;; Action

 

Two way conditional looks like:

 

;;; Action1

else

;;; Alternative action

 

One can do multiway choice using elseif clause

 

;;; Action1

elseif condition2 then

else

;;; Alternative action

 

Instead of if keyword one can use unless keyword.

 

 

has the same meaning as

 

 

One can also use elseunless keword.

 

;;; Action1

elseunless condition2 then

endif;

;;; Action2

 

has the same meaning as

 

;;; Action1

elseif not(condition2) then

;;; Action2

 

Note that conditional must end in matching keyword, if must be finished by endif, unless must be finished by endunless (in the

Pop11 conditional is an expression:

 

 

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

 

case .isstring then printf('A1');

notcase .isinteger then printf('A2');

case > 4 andcase < 15 then printf('A4');

else printf('A5');

 

There is also multiway goto statement and conditional control transfers, we explain them together with other control transfers

Pop11 also has preprocessor allowing conditional compilation:

 

/* Variant 1 */

#_ELSEIF condition2

#_ELSE

/* Variant 3 */

 

condition1 and condition2 are arbitrary Pop11 expressions (they have access to all previously compiled code).

The "<tt>if</tt>" 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):

 

 

The "<tt>ifelse</tt>" operator expects two procedures and executes the one or the other depending on the value of the boolean. I.e. this:

 

 

will render either the string "yeah" or "nope" depending on whether <tt>a</tt> is less than 5 or not.

=={{header|PowerShell}}==

===If, ElseIf, Else===

if (condition) {

# ...

} else {

# ...

===Switch===

switch ($var) {

1 { "Value was 1" }

"\d+" { "Line started with a number" }

"\s+" { "Line started with whitespace" }

 

=={{header|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:

 

 

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

 

fact(bar).

fact(baz).

 

go :- fact(booger).

 

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.

 

( X = foo

; X = bar

go :-

( fact(booger)

 

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):

 

( X = bar -> write('You got me!'), nl

; write(X), write(' is not right!'), nl, fail ).

go :-

( fact(booger)

 

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.

{{works with|PureBasic|4.41}}

===If, Elseif, Else===

Debug "a = 0"

 

Debug "a < 0"

 

 

===Select===

 

Select Variable

Default

Debug "Variable = something else..."

 

===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.

CompilerIf #PB_Compiler_OS = #PB_OS_Linux And #PB_Compiler_Processor = #PB_Processor_x86

Debug "Compiled on x86 Linux"

Debug "Compiled on something else"

CompilerEndIf

 

===CompilerSelect===

CompilerSelect #PB_Compiler_OS

CompilerCase #PB_OS_Linux

Debug "Compiled on something else"

CompilerEndIf

 

=={{header|Python}}==

===if-then-else===

 

foo()

elif x == 1:

baz()

else:

 

===ternary expressions===

'''Interpreter:''' [[Python]] 2.5

 

 

Example:

>>> print 'got it' if secret=='foo' else 'try again'

 

'''Note:''' this syntax is valid as an expression, the clauses cannot constain statements. The foregoing example is equivalent to:

 

>>> result = 'got it' if secret=='foo' else 'try again'

>>> print result

 

===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.

 

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

# or with no "default" case:

if x in dispatcher:

 

dispatcher = {

0: foo,

}

# ...

 

# (it's up to the reader to decide how "pythonic" this is or isn't)

results = {

1: bar,

2: baz,

 

This can be particularly handy when using [[wp:Currying|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.