93 lines
2.0 KiB
Markdown
93 lines
2.0 KiB
Markdown
If Statement
|
|
============
|
|
|
|
{{#include ../links.md}}
|
|
|
|
`if` statements follow C syntax.
|
|
|
|
```rust
|
|
if foo(x) {
|
|
print("It's true!");
|
|
} else if bar == baz {
|
|
print("It's true again!");
|
|
} else if baz.is_foo() {
|
|
print("Yet again true.");
|
|
} else if foo(bar - baz) {
|
|
print("True again... this is getting boring.");
|
|
} else {
|
|
print("It's finally false!");
|
|
}
|
|
```
|
|
|
|
~~~admonish warning.small "Braces are mandatory"
|
|
|
|
Unlike C, the condition expression does _not_ need to be enclosed in parentheses `(`...`)`, but all
|
|
branches of the `if` statement must be enclosed within braces `{`...`}`, even when there is only
|
|
one statement inside the branch.
|
|
|
|
Like Rust, there is no ambiguity regarding which `if` clause a branch belongs to.
|
|
|
|
```rust
|
|
// Rhai is not C!
|
|
if (decision) print(42);
|
|
// ^ syntax error, expecting '{'
|
|
```
|
|
~~~
|
|
|
|
|
|
If Expression
|
|
-------------
|
|
|
|
Like Rust, `if` statements can also be used as _expressions_, replacing the `? :` conditional
|
|
operators in other C-like languages.
|
|
|
|
~~~admonish tip.small "Tip: Disable `if` expressions"
|
|
|
|
`if` expressions can be disabled via [`Engine::set_allow_if_expression`][options].
|
|
~~~
|
|
|
|
```rust
|
|
// The following is equivalent to C: int x = 1 + (decision ? 42 : 123) / 2;
|
|
let x = 1 + if decision { 42 } else { 123 } / 2;
|
|
x == 22;
|
|
|
|
let x = if decision { 42 }; // no else branch defaults to '()'
|
|
x == ();
|
|
```
|
|
|
|
~~~admonish danger.small "Statement before expression"
|
|
|
|
Beware that, like Rust, `if` is parsed primarily as a statement where it makes sense.
|
|
This is to avoid surprises.
|
|
|
|
```rust
|
|
fn index_of(x) {
|
|
// 'if' is parsed primarily as a statement
|
|
if this.contains(x) {
|
|
return this.find_index(x)
|
|
}
|
|
|
|
-1
|
|
}
|
|
```
|
|
|
|
The above will not be parsed as a single expression:
|
|
|
|
```rust
|
|
fn index_of(x) {
|
|
if this.contains(x) { return this.find_index(x) } - 1
|
|
// error due to '() - 1' ^
|
|
}
|
|
|
|
```
|
|
|
|
To force parsing as an expression, parentheses are required:
|
|
|
|
```rust
|
|
fn calc_index(b, offset) {
|
|
(if b { 1 } else { 0 }) + offset
|
|
// ^---------------------^ parentheses
|
|
}
|
|
```
|
|
~~~
|