What is the loop Keyword in Rust?
The loop
keyword defines an infinite loop, making it a simple way to repeatedly execute a block of code until a specific condition is met. You control its termination manually using break, making it highly flexible for scenarios requiring complex exit conditions.
Syntax of the loop Keyword
loop {
// Code to execute
}
- The loop starts executing the block of code immediately and continues indefinitely unless interrupted.
- You can use break to exit the loop or
continue
to skip to the next iteration.
Key Features of the loop Keyword
- Infinite Execution: Runs the block of code forever unless explicitly terminated.
- Manual Termination: Requires a break statement to stop execution.
- Flexible Usage: Can be combined with conditions inside the loop for dynamic exits.
Example: Basic Infinite Loop
fn main() {
loop {
println!("This will print forever!");
}
}
- The above code creates an infinite loop.
- Pressing Ctrl + C (or equivalent) in your terminal is the only way to stop it unless a break statement is added.
Breaking the Loop
The break statement terminates the loop and transfers control to the code following the loop.
Example: Controlled Loop Termination
fn main() {
let mut counter = 0;
loop {
println!("Counter: {}", counter);
counter += 1;
if counter == 5 {
break;
}
}
}
Output:
Counter: 0
Counter: 1
Counter: 2
Counter: 3
Counter: 4
- The loop stops when
counter
reaches 5.
Returning Values from Loops
The loop construct in Rust allows returning a value using the break statement. This feature is particularly useful in scenarios like calculations, searches, or conditions where you want to exit the loop and use the result elsewhere.
Example: Returning a Value
fn main() {
let result = loop {
let mut num = 2;
num *= 2;
if num > 10 {
break num; // Return the value
}
};
println!("The result is: {}", result);
}
Output:
The result is: 16
Nested Loops with loop Keyword
Rust supports nested loops, and you can label loops for better control, especially when using break or continue to exit specific loops.
Example: Breaking a Specific Loop
fn main() {
'outer: loop {
println!("Entering outer loop");
loop {
println!("Inner loop");
break 'outer; // Break the outer loop
}
}
println!("Exited both loops");
}
Output:
Entering outer loop
Inner loop
Exited both loops
- The ‘outer label identifies the outer loop and break ‘outer exits it directly, skipping any remaining iterations.
Using continue with loop
The continue statement skips the remaining code in the current iteration and starts the next iteration.
Example: Skipping Iterations
fn main() {
let mut num = 0;
loop {
num += 1;
if num % 2 == 0 {
continue; // Skip even numbers
}
println!("Odd number: {}", num);
if num >= 10 {
break; // Exit loop when num reaches 10
}
}
}
Output:
Odd number: 1
Odd number: 3
Odd number: 5
Odd number: 7
Odd number: 9
When to Use the loop Keyword?
- Complex Exit Conditions: Use
loop
when the exit condition is not straightforward or cannot be determined upfront. - Server Applications: Ideal for tasks like server loops that should run indefinitely until an external event occurs.
- Polling and Waiting: Perfect for checking conditions continuously, such as waiting for user input or system state changes.
Advantages of Using the loop Keyword
- Simplicity: No need to define conditions at the start.
- Control: Full flexibility to exit or continue based on dynamic conditions.
- Efficiency: Can handle infinite or indefinite tasks effectively.