Conditions and Control Flow
Tags: rust, learning, codenewbie
Published: 2024-07-16 10:02:57

One of the most common tasks when writing code is to check whether certain conditions are `true `or `false`.

####if Expressions
An if expression allows you to branch your code depending on conditions. You provide a condition and then state, “If this condition is met, run this code block. Do not run this code block if the condition is not met.”

#####Using only `if` block:

```
let age = 13;

if age < 18 {
    println!("Hello, child!"); 
}
```
It’s also worth noting that the condition in this code must be a `bool`. We'll get an error if the condition isn’t a `bool`.

#####Using `if` and `else` blocks:

```
fn main() {
    let a = 36;
    let b = 25;

    if a > b {
        println!("a is greater than b");
    } else {
        println!("b is greater than a");
    }
}
```
*Here, I have declared two integer variables, `a` and `b`, with the values '36' and '25'. On line 5, I check if the value stored in the variable `a` is greater than in variable `b`. If the condition is evaluated as `true`, the code on line 6 will be executed. If the condition evaluates to `false`, because we have an `else` block (which is optional), the code on line 8 will get executed.*

#####Using `else if` conditional:

```
fn main() {
    let team_size = 7;
    let team_size_in_text;
    
    if team_size < 5 {
        team_size_in_text = "Small";
    } else if team_size < 10 {
        team_size_in_text = "Medium";
    } else {
        team_size_in_text = "Large";
    }
    
    println!("Current team size : {}", team_size_in_text);
}

```
*In this code, we define a variable `team_size` with a value of `7`. We also declared `team_size_in_text`, but it has not been initialized yet. The first `if` statement checks if `team_size` is less than `5`. If true, `team_size_in_text` is set to `Small`. The `else if` statement checks if `team_size` is less than `10`. Since team_size is `7`, which is less than 10, `team_size_in_text` is set to `Medium`. The final `else` block would execute if neither of the previous conditions was true, setting `team_size_in_text` to `Large.`*

#####Using `if` in a `let` Statement:
Because `if` is an expression, we can use it on the right side of a `let` statement to assign the outcome to a variable. If the types are mismatched, we’ll get an error.

```
fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };

    println!("The value of number is: {number}");
}
```
####Using Loops
The Rust programming language has three different loops based on what you want to achieve and what is available:
* for
* while
* loop

#####for loop
The `for` loop is primarily used to iterate over an iterator. This iterator can be made from anything, from an array, a vector, a range of values, or anything custom.
Here is an example:

```
fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a {
        println!("the value is: {element}");
    }
}
```
*In this code, I declare an array `a` with 5 elements. The `for` loop iterates over each element in the array `a` and prints its value.*

#####while loop
A program will often need to evaluate a condition within a loop. While the condition is `true`, the loop runs. When the condition ceases to be `true`, the program calls `break`, stopping the loop. It’s possible to implement behavior like this using a combination of `loop`, `if`, `else`, and `break`. The while loop stops only when the loop has completed the execution of all statements in the current iteration, and upon checking the condition, it is evaluated as false.
Here is an example:

```
fn main() {
    let mut var = 0;

    while var < 3 {
        println!("{var}");
        var += 1;
    }
}
```
*I have a mutable variable, `var`, with an initial value of `0`. The `while` loop will loop if the value stored in the mutable variable `var` is less than `3`. Inside the loop, var's value gets printed, and later on, its value gets incremented by 1*

#####loop
The `loop` keyword tells Rust to execute a block of code repeatedly forever or until you explicitly tell it to stop.
Here is an example:

```
fn main() {
    loop {
        println!("again!");
    }
}
```
*When we run this program, we’ll see `again!` printed over and over continuously until we stop the program manually. Most terminals support the keyboard shortcut ctrl-c to interrupt a program stuck in a continual loop.*
To stop the execution of an infinite loop, the `break` keyword is used inside the loop.
Here is an example:

```
fn main() {
    let mut var = 0;

    loop {
        if var > 3 {
            break;
        }

        println!("{}", var);
        var += 1;
    }
}
```
*You have a mutable variable `var` with an initial value of `0`. The infinite loop starts with an if condition that should `var`'s value be greater than `3`, the break keyword should be executed. Later on, `var`'s value is printed to the stdout, and then its value is incremented by 1.*