Control Flow in Rust

Introduction link

Control flow in any programming language involves directing the order in which code executes. In Rust, this is achieved through several constructs such as conditional statements, loops, and iterators. These constructs allow you to make decisions, repeat operations, and iterate over data.

Conditional Statements link

Conditional statements let you execute different parts of code based on certain conditions. In Rust, the primary tools for this are if, else, and match.

Example of if Statement:

  let number = 7;

if number < 5 {
    println!("condition was true");
} else {
    println!("condition was false");
}
  

In this example, number is checked to see if it is less than 5. The println! function is called with different arguments based on the result of this check.

Using else if for Multiple Conditions:

  let number = 6;

if number % 4 == 0 {
    println!("number is divisible by 4");
} else if number % 3 == 0 {
    println!("number is divisible by 3");
} else if number % 2 == 0 {
    println!("number is divisible by 2");
} else {
    println!("number is not divisible by 4, 3, or 2");
}
  

This code tests multiple conditions one after the other.

The match Statement: The match statement in Rust is a powerful control flow operator allowing you to compare a value against a series of patterns and execute code based on which pattern matches.

  let state = "happy";

match state {
    "happy" => println!("Smile!"),
    "sad" => println!("Sorry to hear that."),
    _ => println!("Any other state"),
}
  

Here, match checks the value of state and executes the corresponding code block.

Loops and Iterators link

Loops are used to repeat a block of code multiple times. Rust provides several loops constructs: loop, while, and for.

The loop Keyword:

  loop {
    println!("again!");
    break; // Without this break, the loop would run forever.
}
  

loop creates an infinite loop, which must be explicitly exited.

The while Loop:

  let mut number = 3;

while number != 0 {
    println!("{}!", number);
    number -= 1;
}

println!("LIFTOFF!!!");
  

This while loop continues until number is zero.

The for Loop and Iterators:

  let items = [10, 20, 30, 40, 50];

for item in items.iter() {
    println!("the value is: {}", item);
}
  

This for loop iterates over the elements in the array items.

Using for Loop with Range:

  for number in (1..4).rev() {
    println!("{}!", number);
}
println!("LIFTOFF!!!");
  

This code counts down from 3 to 1.

Conclusion link

Understanding and using control flow constructs is fundamental in Rust as they allow you to handle more complex logic and data operations effectively. Conditional statements and loops provide the basic mechanisms to control the flow of execution, while iterators offer a powerful, Rust-idiomatic way to handle sequences and collections.

In our next post, we’ll explore Rust’s ownership model, which plays a crucial role in how data is handled and manipulated in a safe, efficient manner. Stay tuned to deepen your understanding of Rust and continue building your programming skills!