Conditional structures: Difference between revisions
PascalABC.NET
Jazzedpineda (talk | contribs) (Add Plain English) |
(PascalABC.NET) |
||
(25 intermediate revisions by 19 users not shown) | |||
Line 2:
{{Control Structures}}
[[Category:Simple]]
[[Category:Flow control]]
;Task:
Line 587 ⟶ 588:
);</syntaxhighlight>
====case expressions====
Using the same example above, we assume that the
<syntaxhighlight lang="ada">Result := (case Op is
Add => A + B,
Line 596 ⟶ 597:
</syntaxhighlight>
Note: some websites (particularly [https://www.radford.edu/nokie/classes/320/abe/operators.html#:~:text=if%20and%20case-,Examples%3A,1%2C%20others%20%3D%3E%200)%3B this one]) contain a different variant of a case expression (<syntaxhighlight lang="ada">case Op of...</syntaxhighlight>). The Ada Reference Manual indicates this is incorrect, and we use the [http://www.ada-auth.org/standards/12rm/html/RM-4-5-7.html formal version] here.
===case with a default alternative===
<syntaxhighlight lang="ada">type Days is (Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday);
Line 613 ⟶ 615:
===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
<syntaxhighlight lang="ada">case Today is
Line 625 ⟶ 627:
end case;</syntaxhighlight>
The
<syntaxhighlight lang="ada">case Today is
Line 1,740 ⟶ 1,742:
<syntaxhighlight lang="befunge">& #v_ "0",@ zero
> "X",@ non-zero</syntaxhighlight>
=={{header|Binary Lambda Calculus}}==
Lambda calculus has no conditional structures built in, but the standard representations of booleans can be seen to implement if-then-else: true = \then. \else. then, false = \then. \else. else, which correspond to BLC programs <code>00 00 110</code> and <code>00 00 10</code>.
=={{header|blz}}==
Line 2,283 ⟶ 2,289:
// if condition is true var will be set to 1, else false.
int var = condition ? 1 : 2;
</syntaxhighlight>
=={{header|Curto}}==
===si-sino===
<syntaxhighlight lang="curto">( condición ) si ( sentencias si verdadero ) entonces
( condición ) si ( sentencias si verdadero ) sino ( sentencias si falso ) entonces</syntaxhighlight>
ejemplo:
<syntaxhighlight lang="curto">
: menor-que-diez ( n -- )
10 < si
." Menor que 10"
sino
." Mayor o igual a 10"
entonces ;
</syntaxhighlight>
Line 2,473 ⟶ 2,492:
=={{header|EasyLang}}==
<syntaxhighlight
i = randint 10
if i mod 2 = 0
print i & " is divisible by 2"
elif i mod 3 = 0
print i & " is divisible by 3"
else
print i & " is not divisible by 2 or 3"
.
</syntaxhighlight>
=={{header|Ed}}==
Note that ed, unlike more advanced [[Sed]], has no conditional branching. Still, conditionals can be simulated with global match/no-match rules:
<syntaxhighlight>
g/True/s//It's true!/p
v/True/s/.*/It's false!/p
</syntaxhighlight>
=={{header|Efene}}==
Line 2,570 ⟶ 2,600:
x::xs = x :: force xs
[] = []</syntaxhighlight>
=={{header|EMal}}==
<syntaxhighlight lang="emal">
int i = 19
^|if–then–else|^
if i > 18
writeLine("greater than 18")
else
writeLine("less or equal to 18")
end
^|else if|^
if i == 18 do writeLine("equal to 18")
else if i < 18 do writeLine("less than 18")
else do writeLine("greater than 18")
end
^|when expression: just like iif in Visual Basic|^
writeLine(when(i > 18, "greater than 18", "less or equal to 18"))
^|hash-based conditionals|^
Map dispatch = int%fun[
18 => <|writeLine("equal to 18"),
19 => <|writeLine("yeah, it's 19")]
if dispatch.has(i) do dispatch[i]() end
</syntaxhighlight>
{{out}}
<pre>
greater than 18
greater than 18
greater than 18
yeah, it's 19
</pre>
=={{header|Erlang}}==
Line 3,408 ⟶ 3,469:
=={{header|J}}==
See [[Conditional Structures/J]]
=={{header|Jakt}}==
<syntaxhighlight lang="jakt">
fn main() {
let a = 5
let b = 3
// If/else/else-if
if a > b {
println("a > b")
} else if a < b {
println("a < b")
} else {
println("a = b")
}
// Match
match a {
(..5) => {
println("a < 5")
}
5 => {
println("a == 5")
}
else => {
println("a > 5")
}
}
// Or equivalently
println(match a {
(..5) => "a < 5"
5 => "a == 5"
else => "a > 5"
})
// Hash based
let primality = [
1: false
2: false
3: true
4: false
5: true
6: false
]
let a_is_prime = primality[a]
println("a_is_prime = {}", a_is_prime)
}
</syntaxhighlight>
=={{header|Java}}==
===if-then-else===
<syntaxhighlight lang="java">if (s.equals("Hello World")) {
foo();
} else if (s.equals("Bye World"))
bar(); // braces optional for one-liners
else {
deusEx();
}</syntaxhighlight>
Java also supports [[wp:Short-circuit_evaluation|short-circuit evaluation]]. So in a conditional like this:
<syntaxhighlight lang="java">if (obj != null && obj.foo()) {
aMethod();
}</syntaxhighlight>
<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:
<syntaxhighlight lang="java">if (obj != null & obj.foo()) {
aMethod();
}</syntaxhighlight>
You will get a null pointer exception if <tt>obj</tt> is null.
===ternary===
<syntaxhighlight lang="java">s.equals("Hello World") ? foo() : bar();</syntaxhighlight>
The ternary operator is an expression, and is most often used as such:
<syntaxhighlight lang="java">Object newValue = s.equals("Hello World") ? a : b;</syntaxhighlight>
===switch===
This structure will only work if the code being switched on evaluates to an integer or character. There is no switching on
<syntaxhighlight lang="java">switch (c) {
case 'a':
foo();
break;
case 'b':
bar();
default:
foobar();
}</syntaxhighlight>
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
<syntaxhighlight lang="java">if (c == 'a') {
foo();
} else if (c == 'b') {
bar();
foobar();
} else {
foobar();
}</syntaxhighlight>
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).
===switch expressions===
{{works with|Java|14+}}
Switch statements can be expressions. They must be exhaustive, and return a value with the <tt>yield</tt> keyword.
<syntaxhighlight lang=“java”>int x = switch (c) {
case 'a':
foo();
yield 1;
case 'b':
bar();
default:
foobar();
yield 0;
}</syntaxhighlight>
There is also a new syntax, available for both statements and expressions, that does not use fallthrough:
<syntaxhighlight lang=“java”>int y = switch (c) {
case '1', '2' -> 1 // multiple cases can be on one line
default -> { // use a block for multiple statements
foobar();
yield 0;
}
}</syntaxhighlight>
=={{header|JavaScript}}==
Line 3,773 ⟶ 3,904:
=={{header|langur}}==
If and switch
===if expressions===
If expressions are scoped per section.
<syntaxhighlight lang="langur">if
...
} else if
val
...
} else {
val
...
}</syntaxhighlight>
Line 3,794 ⟶ 3,923:
This is more flexible than a ternary operator, as it allows more than one test. An else section is optional (null by default).
<syntaxhighlight lang="langur">if(
===simple if===
<syntaxhighlight lang="langur">if
===switch
Switch
Switch
<syntaxhighlight lang="langur">switch
case true: ...
# any are true
case false, _: ...
#
case _, null, true: ...
#
case xor _, true, true: ...
#
}
switch 0 {
case
#
...
}
case true: ...
# all are true
case false, _: ...
#
case _, null, true: ...
#
}</syntaxhighlight>
===implicit fallthrough===
If a block of a switch
<syntaxhighlight lang="langur">
case true:
# implicit fallthrough
Line 3,845 ⟶ 3,974:
===explicit fallthrough from anywhere===
A fallthrough statement is allowed anywhere within a switch
<syntaxhighlight lang="langur">switch x {
case true:
if
fallthrough
} else {
Line 3,856 ⟶ 3,986:
}</syntaxhighlight>
===shortened form switch
A shortened form expects a single action expression per test and is more limited in other ways, as well (no explicit fallthrough, no alternate test expressions, no alternate logical operators). A default section is optional (null by default).
<syntaxhighlight lang="langur">
true: ... ; #
_, >=
... ) # default</syntaxhighlight>
Line 5,136 ⟶ 5,266:
=={{header|Ol}}==
if-then, the simplest conditional `if` primitive.
<syntaxhighlight lang="scheme">
(if (= (* 2 2) 4
(if (= (* 2 2) 6)
(print "if-then: should not be printed"))
; ==> if-then: equal
</syntaxhighlight>
if-then-else, the full conditional
<syntaxhighlight lang="scheme">
(if (= (* 2 2) 4
(print "if-then-else: non equal"))
; ==> if-then-else: equal
(if (= (* 2 2) 6)
(print "if-then-else: equal")
(print "if-then-else: non equal"))
; ==> if-then-else: non equal
</syntaxhighlight>
when and unless, the
<syntaxhighlight lang="scheme">
(
; ==> when: ..just do something..
; ==>
(unless (= (* 2 2) 6)
(print "unless: ..just do something..")
(print "unless: not equal"))
; ==> unless: ..just do something..
; ==> unless: not equal
</syntaxhighlight>
if-then-else, extended conditional `if` primitive.
<syntaxhighlight lang="scheme">
(if (= (* 2 2) 4)
(print "if-then-else*: equal")
else
(print "if-then-else*: ..just do something..")
(print "if-then-else*: non equal"))
; ==> if-then-else*: equal
(if (= (* 2 2) 4)
then
(print "if-then-else*: ..just do something..")
(print "if-then-else*: equal")
else
(print "if-then-else*: ..just do something..")
(print "if-then-else*: non equal"))
; ==> if-then-else*: ..just do something..
; ==> if-then-else*: equal
(if (= (* 2 2) 4) ; same as `when`
then
(print "if-then-else*: ..just do something..")
(print "if-then-else*: equal"))
; ==> if-then-else*: ..just do something..
; ==> if-then-else*: equal
</syntaxhighlight>
Line 5,165 ⟶ 5,333:
<syntaxhighlight lang="scheme">
(case (* 2 2)
(3 ; exact number
(print "case: 3"))
(4 ; exact number
(print "case: 4"))
((5 6 7) ; list of numbers
(print "case: 5 or 6 or 7"))
(else
(print "case: i don't know")))
; ==> case: 4
; extended case with usable else
(case (* 2 2)
(3 ; exact number
(print "case: 3"))
(else => (lambda (num)
(print "case: real value is " num))))
; ==> case: real value is 4
(case (* 2 2)
(3 ; exact number
(print "case: 3"))
(else is num
(print "case: real value is " num)))
; ==> case: real value is 4
; extended case with vectors
(case ['selector 1 2 3]
(['case1 x y]
(print "case: case1 " x ", " y))
Line 5,185 ⟶ 5,366:
(else
(print "case: i don't know")))
; ==>
</syntaxhighlight>
Line 5,348 ⟶ 5,529:
PARI can use all of the usual [[Conditional structures/C|C conditionals]].
=={{header|PascalABC.NET}}==
<syntaxhighlight lang="delphi">
// if statement
if condition then
operator;
if condition then
operator
else operator;
if condition then
operator
else if condition then
operator
else operator;
// case statement
case Month of
3..5: Print('Spring');
6..8: Print('Summer');
9..11: Print('Autumn');
12,1,2: Print('Winter');
else throw ArgumentException('Bad Month')
end;
// ternary operator
var min := if a < b then a else b;
// ternary operator in C style
var min := a < b ? a : b;
</syntaxhighlight>
=={{header|Pascal}}==
Line 6,399 ⟶ 6,612:
(<code>]'[</code>, pronounced "meta-literal" grants the property of <code>'</code> (pronounced "literal", <code>'</code> places the item following it on the stack and unconditionally branches over it) to the enclosing nest.)
See [[Flow-control structures#Quackery]] for a deeper dive into Quackery control flow.
=={{header|R}}==
Line 6,736 ⟶ 6,951:
}}
</syntaxhighlight>
=={{header|RPL}}==
'''IF..THEN'''
'''IF''' <instruction(s)> '''THEN''' <instruction(s)> '''END'''
'''IF..THEN..ELSE'''
'''IF''' <instruction(s)> '''THEN''' <instruction(s)> '''ELSE''' <instruction(s)> '''END'''
Instructions between <code>IF</code> and <code>THEN</code> are not mandatory, but recommended for lisibility. The interpreter considers <code>IF</code> as a null word and performs branching when meeting the word <code>THEN</code>: if stack level 1 is not equal to zero, the instructions between <code>THEN</code> and <code>END</code> will be executed.
<code>IFT</code> and <code>IFTE</code> are stack-based conditonal structures. <code>IFT</code> evaluates the content of stack level 1 only if the content of stack level 2 is not zero, otherwise it is dropped. <code>IFTE</code> evaluates the content of stack level 1 if the content of stack level 2 is zero, otherwise if evaluates the content of stack level 2.
'''CASE..END'''
'''CASE'''
<instruction(s)> '''THEN''' <instruction(s)> '''END'''
<instruction(s)> '''THEN''' <instruction(s)> '''END'''
<span style="color:grey">@ as many branches as needed</span>
<instruction(s)> <span style="color:grey">@ default branch (optional)</span>
'''END'''
=={{header|Ruby}}==
Line 7,209 ⟶ 7,441:
(else 'zero))</syntaxhighlight>
=={{header|SmallBASIC}}==
===if===
<syntaxhighlight lang="basic">
IF foo == 1
PRINT "one"
ELSEIF foo == 2
PRINT "two"
ELSE
PRINT "something else"
ENDIF
</syntaxhighlight>
===Inline if===
<syntaxhighlight lang="basic">ans = iff(x <= 5, 0, 10)</syntaxhighlight>
===select===
<syntaxhighlight lang="basic">
select case x
case 12
print "x is 12"
case 13,14,15
print "x is 13,14,or 15"
case iff(x <= 4, x, x + 1)
print "x <= 4"
case else
print "x is not <=4,12,13,14,15"
end select
</syntaxhighlight>
=={{header|Smalltalk}}==
Line 7,830 ⟶ 8,089:
There are optional <code>elif</code> (else if) and <code>else</code> clauses.
<syntaxhighlight lang="sh">if test 4 -ge 6
elif test 4 -lt 6
else echo '4 compares not to 6'
fi</syntaxhighlight>
Line 7,896 ⟶ 8,154:
else
x * fac (Nat.drop x 1)</syntaxhighlight>
=={{header|Ursalang}}==
===if…then…else===
Ursalang has a single conditional construct, the familiar `if…then…else`.<syntaxhighlight lang="ursalang">
if energyLevel > 9000 { "That's impossible!!!" } else { "Ok, I guess" }
</syntaxhighlight>As in most C-like languages, conditionals can be chained:<syntaxhighlight>
if color == "red" { "aaaaaah!" }
else if color == "blue" { "oooooh!" }
else { "eeeeeeee!" }
</syntaxhighlight>
=={{header|V}}==
Line 8,422 ⟶ 8,690:
=={{header|Wren}}==
The ''if/else'' statement and the ''ternary operator (?:)'' are Wren's basic conditional structures though it can be argued that the ''&&'' and ''||'' operators, which do short-circuit evaluation, should be included under this heading as well.
<syntaxhighlight lang="
if (b) {
System.print(true)
|