How many types of loops are available in Rust?

Rust provides three main types of loops: loop (infinite loop), while (conditional loop), and for (iterator loop). Each serves a different purpose depending on the situation.

What is the difference between for and while loops in Rust?

The for loop is typically used to iterate over ranges or collections and is considered more idiomatic in Rust. The while loop runs as long as a Boolean condition remains true.

Can a loop return a value in Rust?

Yes. The loop keyword in Rust can return a value using the break statement with a value, making it an expression.

What does the continue statement do in Rust loops?

The continue statement skips the current iteration of the loop and moves directly to the next iteration.

What is the difference between .. and ..= in Rust loops?

The .. operator creates an exclusive range that excludes the ending value, while the ..= operator creates an inclusive range that includes the ending value.

When should I use the loop keyword in Rust?

Use the loop keyword when you need an infinite loop or when you want to return a value from a loop using break.

Rust Loops

Q: Which loop is most commonly used in Rust?

The for loop is the most commonly used and idiomatic loop in Rust, especially for iterating over ranges and collections.

Rust Loops – Complete Beginner Guide

Loops are one of the most powerful tools in programming.

They allow your program to:

Repeat actions
Process collections
Automate repetitive tasks
Build real-world logic
Handle dynamic data

In Rust, loops are safe, flexible, and expressive.

If you’re learning Rust, mastering loops is essential.

In this complete beginner guide, you’ll learn:

What loops are in Rust
The three types of loops
loop
while
for
Breaking and continuing
Loop labels
Loop expressions
Common mistakes
Best practices
Real-world examples

Let’s dive in

What Are Loops in Rust?

A loop allows code to execute repeatedly until a condition is met.

Without loops, you would have to write repetitive code manually.

Example without loop:

println!("Hello");
println!("Hello");
println!("Hello");

println!("Hello");

With loop:

for _ in 0..3 {
println!("Hello");
}

for _ in 0..3 {

println!("Hello");

}

Much cleaner and scalable.

Types of Loops in Rust

Rust provides three types of loops:

loop (infinite loop)
while (conditional loop)
for (iterator loop)

Each has its own use case.

The `loop` Keyword (Infinite Loop)

loop creates an infinite loop.

Example:

fn main() {
loop {
println!("Running forever...");
}
}

fn main() {

loop {

println!("Running forever...");

}

This will run forever unless stopped manually.

Breaking Out of a `loop`

Use break to exit.

fn main() {
let mut count = 0;loop {
if count == 5 {
break;
}println!("{}", count);
count += 1;
}
}

fn main() {

let mut count = 0;loop {

if count == 5 {

break;

}println!("{}", count);

count += 1;

}

This prints numbers 0 to 4.

Returning Values from a Loop

Rust allows loop to return a value.

Example:

fn main() {
let mut counter = 0;let result = loop {
counter += 1;if counter == 10 {
break counter * 2;
}
};

println!("Result: {}", result);
}

fn main() {

let mut counter = 0;let result = loop {

counter += 1;if counter == 10 {

break counter * 2;

}

};

println!("Result: {}", result);

}

This is unique and powerful.

The `while` Loop

The while loop runs while a condition is true.

Syntax:

while condition {
// code
}

while condition {

// code

}

Example:

fn main() {
let mut number = 5;while number > 0 {
println!("{}", number);
number -= 1;
}
}

fn main() {

let mut number = 5;while number > 0 {

println!("{}", number);

number -= 1;

}

Runs until condition becomes false.

Important Rule

The condition must evaluate to a Boolean.

Rust does NOT allow:

while 1 {
}

1 2	while 1 { }

The condition must be explicit.

The `for` Loop (Most Common in Rust)

The for loop is used to iterate over a range or collection.

Example with range:

fn main() {
for i in 1..5 {
println!("{}", i);
}
}

fn main() {

for i in 1..5 {

println!("{}", i);

}

Output:

1
2
3
4

Note: 1..5 excludes 5.

Inclusive Range

for i in 1..=5 {
println!("{}", i);
}

for i in 1..=5 {

println!("{}", i);

}

Includes 5.

Iterating Over Arrays

fn main() {
let numbers = [10, 20, 30, 40];for number in numbers {
println!("{}", number);
}
}

fn main() {

let numbers = [10, 20, 30, 40];for number in numbers {

println!("{}", number);

}

Clean and safe iteration.

Using `continue` in Loops

continue skips the current iteration.

Example:

fn main() {
for i in 1..6 {
if i == 3 {
continue;
}println!("{}", i);
}
}

fn main() {

for i in 1..6 {

if i == 3 {

continue;

}println!("{}", i);

}

3 is skipped.

Using `break` in Loops

Stops the loop immediately.

Example:

for i in 1..10 {
if i == 5 {
break;
}println!("{}", i);
}

for i in 1..10 {

if i == 5 {

break;

}println!("{}", i);

}

Stops when i becomes 5.

Loop Labels (Advanced but Useful)

Rust supports labeled loops.

Example:

fn main() {
'outer: loop {
println!("Outer loop");loop {
println!("Inner loop");
break 'outer;
}
}
}

fn main() {

'outer: loop {

println!("Outer loop");loop {

println!("Inner loop");

break 'outer;

}

This breaks the outer loop from inside the inner loop.

Infinite Loops with Conditions

Instead of:

while true {
}

1 2	while true { }

Use:

loop {
}

loop {

}

Cleaner and more idiomatic.

Looping with `enumerate()`

You can get index and value.

fn main() {
let items = ["A", "B", "C"];for (index, value) in items.iter().enumerate() {
println!("{}: {}", index, value);
}
}

fn main() {

let items = ["A", "B", "C"];for (index, value) in items.iter().enumerate() {

println!("{}: {}", index, value);

}

Very useful in real projects.

Real-World Example: Simple Counter App

fn main() {
let mut count = 0;while count < 5 {
println!("Count: {}", count);
count += 1;
}
}

fn main() {

let mut count = 0;while count < 5 {

println!("Count: {}", count);

count += 1;

}

Common in games, timers, simulations.

Real-World Example: Finding Even Numbers

fn main() {
for i in 1..=10 {
if i % 2 == 0 {
println!("Even: {}", i);
     }
   }
}

fn main() {

for i in 1..=10 {

if i % 2 == 0 {

println!("Even: {}", i);

}

Combines loops and conditions.

Nested Loops

You can nest loops inside loops.

Example:

fn main() {
for i in 1..=3 {
for j in 1..=3 {
println!("({}, {})", i, j);
         }
      }
  }

fn main() {

for i in 1..=3 {

for j in 1..=3 {

println!("({}, {})", i, j);

}

Used in:

Matrix operations
Grid systems
Games
Algorithms

Common Beginner Mistakes

Forgetting mut for counters
Infinite loops without break
Wrong range (exclusive vs inclusive)
Using while true instead of loop
Modifying collection while iterating

Loop Performance in Rust

Rust loops are:

Memory-safe
Fast
Optimized by compiler
Zero-cost abstractions

The for loop is preferred over manual indexing.

Instead of:

for i in 0..array.len() {
println!("{}", array[i]);
}

for i in 0..array.len() {

println!("{}", array[i]);

}

Write:

for item in array {
println!("{}", item);
}

for item in array {

println!("{}", item);

}

Cleaner and safer.

Best Practices for Rust Loops

Prefer for over while when iterating
Use loop only when necessary
Avoid deep nesting
Use clear variable names
Keep loop bodies small
Break early when possible

When to Use Each Loop Type

Makeloop when:

You need infinite looping
You want to return values

Use while when:

Loop depends on condition

Use for when:

Iterating over ranges
Working with collections
Writing idiomatic Rust

Frequently Asked Questions (FAQs)

1. How many types of loops are in Rust?

Rust has three main loop types: loop, while, and for.

2. What is the difference between for and while in Rust?

for is used for iterating over ranges and collections, while while runs as long as a condition remains true.

3. Can loops return values in Rust?

Yes. The loop keyword can return a value using break.

4. What does `continue` do in Rust loops?

It skips the current iteration and moves to the next one.

5. Which loop is most commonly used in Rust?

The for loop is the most commonly used and idiomatic loop in Rust.

Final Thoughts

Rust loop are:

Powerful
Safe
Flexible
Expressive
Efficient

They allow you to:

Repeat tasks
Process data
Build algorithms
Create real-world applications

Mastering loop is a major milestone in your Rust learning journey.

Rust Loops

Rust Loops – Complete Beginner Guide

What Are Loops in Rust?

Types of Loops in Rust

The `loop` Keyword (Infinite Loop)

Breaking Out of a `loop`

Returning Values from a Loop

The `while` Loop

Important Rule

The `for` Loop (Most Common in Rust)

Inclusive Range

Iterating Over Arrays

Using `continue` in Loops

Using `break` in Loops

Loop Labels (Advanced but Useful)

Infinite Loops with Conditions

Looping with `enumerate()`

Real-World Example: Simple Counter App

Real-World Example: Finding Even Numbers

Nested Loops

Common Beginner Mistakes

Loop Performance in Rust

Best Practices for Rust Loops

When to Use Each Loop Type

Frequently Asked Questions (FAQs)

1. How many types of loops are in Rust?

2. What is the difference between for and while in Rust?

3. Can loops return values in Rust?

4. What does `continue` do in Rust loops?

5. Which loop is most commonly used in Rust?

Final Thoughts

You may also like...

Rust Tutorial

Rust Data Structures

Rust Loops

Rust Loops – Complete Beginner Guide

What Are Loops in Rust?

Types of Loops in Rust

The loop Keyword (Infinite Loop)

Breaking Out of a loop

Returning Values from a Loop

The while Loop

Important Rule

The for Loop (Most Common in Rust)

Inclusive Range

Iterating Over Arrays

Using continue in Loops

Using break in Loops

Loop Labels (Advanced but Useful)

Infinite Loops with Conditions

Looping with enumerate()

Real-World Example: Simple Counter App

Real-World Example: Finding Even Numbers

Nested Loops

Common Beginner Mistakes

Loop Performance in Rust

Best Practices for Rust Loops

When to Use Each Loop Type

Frequently Asked Questions (FAQs)

1. How many types of loops are in Rust?

2. What is the difference between for and while in Rust?

3. Can loops return values in Rust?

4. What does continue do in Rust loops?

5. Which loop is most commonly used in Rust?

Final Thoughts

You may also like...

Rust Functions

Rust Comments

Rust while Loops

Rust Tutorial

Rust Data Structures

The `loop` Keyword (Infinite Loop)

Breaking Out of a `loop`

The `while` Loop

The `for` Loop (Most Common in Rust)

Using `continue` in Loops

Using `break` in Loops

Looping with `enumerate()`

4. What does `continue` do in Rust loops?