Control Flow
if
expressions
Sway supports if, else, and else if expressions that allow you to branch your code depending on conditions.
For example:
fn main() {
let number = 6;
if number % 4 == 0 {
// do something
} else if number % 3 == 0 {
// do something else
} else {
// do something else
}
}
Using if
in a let
statement
Like Rust, if
s are expressions in Sway. What this means is you can use if
expressions on the right side of a let
statement to assign the outcome to a variable.
let my_data = if some_bool < 10 { foo() } else { bar() };
Note that all branches of the if
expression must return a value of the same type.
match
expressions
Sway supports advanced pattern matching through exhaustive match
expressions.
script;
fn foo() {}
// do something
fn bar() {}
// do something
enum SomeEnum {
A: u64,
B: bool,
C: b256,
}
fn main() -> u64 {
let x = 5;
// Match as an expression.
let a = match 8 {
7 => 4,
9 => 5,
8 => 6,
_ => 100,
};
// Match as a statement for control flow.
match x {
5 => foo(),
_ => bar(),
};
// Match an enum
let e = SomeEnum::A(42);
let v = match e {
SomeEnum::A(val) => val,
SomeEnum::B(true) => 1,
SomeEnum::B(false) => 0,
_ => 0,
};
// Match as expression used for a return.
match 42 {
0 => 24,
foo => foo,
}
}
Loops
while
Loops in Sway are currently limited to while
loops. This is what they look like:
while counter < 10 {
counter = counter + 1;
}
You need the while
keyword, some condition (value < 10
in this case) which will be evaluated each iteration, and a block of code inside the curly braces ({...}
) to execute each iteration.
break
and continue
break
and continue
keywords are available to use inside the body of a while
loop. The purpose of the break
statement is to break out of a loop early:
fn break_example() -> u64 {
let mut counter = 1;
let mut sum = 0;
let num = 10;
while true {
if counter > num {
break;
}
sum += counter;
counter += 1;
}
sum // 1 + 2 + .. + 10 = 55
}
The purpose of the continue
statement is to skip a portion of a loop in an iteration and jump directly into the next iteration:
fn continue_example() -> u64 {
let mut counter = 0;
let mut sum = 0;
let num = 10;
while counter < num {
counter += 1;
if counter % 2 == 0 {
continue;
}
sum += counter;
}
sum // 1 + 3 + .. + 9 = 25
}
Nested loops
You can also use nested while
loops if needed:
while condition_1 == true {
// do stuff...
while condition_2 == true {
// do more stuff...
}
}