Rust Language - 8 - Control Structures (if, match, loop)

Control Structures in Rust: if, match, and loop for Flow Control

Control structures are essential tools for directing the flow of your code. In Rust, you have access to three primary control structures: if, match, and loop. In this article, we’ll explore these structures, their usage, and examples to illustrate their role in shaping the logic of your Rust programs.

1. The if Expression

The if expression is a fundamental tool for making decisions in Rust. It allows you to conditionally execute code based on a boolean expression. An if block can have two branches: one for when the condition is true and another for when it’s false.

Example of if Expression:

fn main() {
    let number = 5;

    if number < 0 {
        println!("Number is negative");
    } else if number == 0 {
        println!("Number is zero");
    } else {
        println!("Number is positive");
    }
}

In this example, the code checks whether the variable number is negative, zero, or positive and prints the corresponding message accordingly. The if expression allows you to make choices and control the program’s flow.

2. The match Expression

The match expression is a versatile construct for pattern matching in Rust. It’s used for handling complex control flow and is especially powerful for working with enums and custom data types. A match block contains patterns and associated code to be executed when a pattern matches.

Example of match Expression:

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

fn main() {
    let coin = Coin::Dime;
    let value = value_in_cents(coin);
    println!("The coin's value is {} cents", value);
}

In this example, the match expression is used to determine the value of a coin by matching it to an enum variant. The code associated with the matching variant is executed. The match expression is particularly useful for working with complex data structures.

3. The loop Construct

Rust provides several ways to create loops, but the most basic is the loop construct. It allows you to create an infinite loop that can be terminated using the break keyword. loop is useful for scenarios where you need to repeatedly execute a block of code until a specific condition is met.

Example of loop Construct:

fn main() {
    let mut counter = 0;

    loop {
        println!("Current count: {}", counter);
        counter += 1;

        if counter >= 5 {
            break;
        }
    }
}

In this example, the loop construct is used to print the value of the counter variable and increment it until it reaches 5, at which point the loop is terminated using break.

4. Combining Control Structures

Rust allows you to combine these control structures to create more complex logic. For example, you can use if within a match branch or place a match expression inside a loop to handle different cases in an iterative process. This flexibility is invaluable for solving a wide range of programming challenges.

5. Conclusion

Control structures are the building blocks of program logic in Rust. The if expression, match expression, and loop construct enable you to make decisions, handle complex data patterns, and create iterative processes. Understanding how to use these control structures effectively is essential for writing well-structured and efficient Rust programs.

Rust Language – 8 – Control Structures (if, match, loop)