What is the difference between while and loop in Rust?

The while loop runs as long as a condition is true, whereas the loop keyword creates an infinite loop that must be exited using break.

Can a while loop return a value in Rust?

No. A while loop cannot directly return a value. Only the loop keyword supports returning a value using break.

When should I use while instead of for in Rust?

You should use while when repetition depends on a dynamic condition or when you need manual control over loop behavior. For iterating over collections, the for loop is usually preferred.

Can a while loop cause an infinite loop in Rust?

Yes. If the loop condition never becomes false or is always true, the while loop will run indefinitely unless stopped manually.

Rust while Loops

Q: What is a while loop in Rust?

A while loop in Rust repeatedly executes a block of code as long as a Boolean condition remains true. The condition is checked before each iteration.

Rust `while` Loop – Complete Beginner Guide

Loops are fundamental in programming, and Rust provides several ways to repeat code. While the for loop is commonly preferred, the while loop is powerful when you need condition-based repetition.

In this fully beginner guide, you’ll learn:

What a while loop is in Rust
Basic syntax and examples
Infinite loops with loop
Loop control (break, continue)
Ownership considerations
Common mistakes
Best practices

Let’s dive in

What Is a `while` Loop in Rust?

A while loop repeatedly executes code as long as a condition is true.

Basic syntax:

while condition {
// code runs while condition is true
}

while condition {

// code runs while condition is true

}

Unlike Rust’s for loop (which works with iterators), the while loop depends on a Boolean condition.

Basic Example – Counting with While

fn main() {
let mut count = 1;

while count <= 5 {
println!("{}", count);
count += 1;
}
}

fn main() {

let mut count = 1;

while count <= 5 {

println!("{}", count);

count += 1;

}

Output:

Important:

Condition is checked before each iteration
Loop stops when condition becomes false

How `while` Loop Works Internally

Execution flow:

Check condition
If true → execute block
Return to condition
Repeat

Infinite While Loop

If the condition never becomes false:

fn main() {
while true {
println!("Running...");
}
}

fn main() {

while true {

println!("Running...");

}

This runs forever unless stopped.

Rust provides a better infinite loop syntax:

loop {
println!("Infinite loop");
}

loop {

println!("Infinite loop");

}

The loop keyword is more idiomatic for infinite loops.

Breaking Out of a Loop

Use break to exit early.

fn main() {
let mut num = 1;

while num <= 10 {
if num == 5 {
break;
}
println!("{}", num);
num += 1;
}
}

fn main() {

let mut num = 1;

while num <= 10 {

if num == 5 {

break;

}

println!("{}", num);

num += 1;

}

Loop stops at 5.

Skipping Iterations with continue

fn main() {
let mut num = 0;

while num < 5 {
num += 1;

if num == 3 {
continue;
}

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

fn main() {

let mut num = 0;

while num < 5 {

num += 1;

if num == 3 {

continue;

}

println!("{}", num);

}

continue skips current iteration.

While vs Loop in Rust

Feature	while	loop
Condition-based	Yes	No
Infinite by default	No	Yes
Returns value	No	Yes
Common usage	Conditional repetition	Infinite or complex loops

Returning Values from loop (Not While)

The loop keyword can return values:

fn main() {
let mut counter = 0;

let result = loop {
counter += 1;

if counter == 5 {
break counter * 2;
}
};

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

fn main() {

let mut counter = 0;

let result = loop {

counter += 1;

if counter == 5 {

break counter * 2;

}

};

println!("{}", result);

}

Output:

while cannot return values directly.

While Loop with Ownership

Ownership rules apply inside loops.

Example:

let s = String::from("Rust");

while true {
println!("{}", s);
break;
}

let s = String::from("Rust");

while true {

println!("{}", s);

break;

}

This works because ownership is not moved.

But:

let s = String::from("Rust");

while true {
let t = s;
break;
}

let s = String::from("Rust");

while true {

let t = s;

break;

}

Here:

Ownership moves
s becomes invalid

Loops do not bypass ownership rules.

While Loop and Mutable Variables

Since condition must change, variables are often mut.

let mut x = 10;

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

let mut x = 10;

while x > 0 {

println!("{}", x);

x -= 1;

}

If you forget mut, Rust gives compile-time error.

Using While with Collections

You can manually loop through array using index:

let numbers = [10, 20, 30];
let mut index = 0;

while index < numbers.len() {
println!("{}", numbers[index]);
index += 1;
}

let numbers = [10, 20, 30];

let mut index = 0;

while index < numbers.len() {

println!("{}", numbers[index]);

index += 1;

}

But this is less safe than using for.

Rust recommends for for iterating collections.

When Should You Use While?

Use while when:

You don’t know number of iterations
Loop depends on dynamic condition
You need manual control

Examples:

User input validation
Game loops
Waiting for event

Example – Guessing Game Pattern

let mut guess = 0;

while guess != 7 {
guess += 1;
println!("Guessing...");
}

let mut guess = 0;

while guess != 7 {

guess += 1;

println!("Guessing...");

}

Loop runs until condition satisfied.

Nested While Loops

let mut i = 1;

while i <= 3 {
let mut j = 1;

while j <= 3 {
println!("{} {}", i, j);
j += 1;
}

i += 1;
}

let mut i = 1;

while i <= 3 {

let mut j = 1;

while j <= 3 {

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

j += 1;

}

i += 1;

}

Used in:

Matrix operations
Pattern printing

Common Beginner Mistakes

Forgetting to update condition variable
Creating infinite loops unintentionally
Forgetting mut keyword
Using while instead of for unnecessarily
Moving ownership accidentally inside loop

While vs For Loop in Rust

Rust prefers for when:

Iterating over ranges
Iterating collections
Working with iterators

Use while when:

Condition-based repetition
Manual control needed

Safety in Rust While Loops

Rust ensures:

No data races
No invalid memory access
Ownership rules enforced

Even inside loops, Rust maintains memory safety.

Best Practices

Use for for iteration
Use while for condition-based loops
Always ensure condition changes
Keep loops readable
Avoid complex nested loops

Real-World Example – Countdown Timer

let mut seconds = 5;

while seconds > 0 {
println!("{} seconds left", seconds);
seconds -= 1;
}

println!("Time's up!");

let mut seconds = 5;

while seconds > 0 {

println!("{} seconds left", seconds);

seconds -= 1;

}

println!("Time's up!");

Clean and predictable.

Frequently Asked Questions (FAQs)

1. What is a while loop in Rust?

A while loop repeats code as long as a Boolean condition remains true.

2. What is the difference between while and loop?

while depends on a condition.
loop runs infinitely unless stopped.

3. Can a while loop return a value?

No. Only loop can return a value using break.

4. When should I use while instead of for?

Use while when repetition depends on a dynamic condition.

5. Can while loops cause infinite loops?

Yes, if the condition never becomes false.

Conclusion

Rust’s while loop is:

Simple
Condition-based
Safe
Ownership-aware

You learned:

Basic syntax
Infinite loops
Break and continue
Ownership inside loops
When to use while

Mastering loops is essential for writing real-world Rust programs.

Rust while Loops

Rust `while` Loop – Complete Beginner Guide

What Is a `while` Loop in Rust?

Basic Example – Counting with While

How `while` Loop Works Internally

Infinite While Loop

Breaking Out of a Loop

Skipping Iterations with continue

While vs Loop in Rust

Returning Values from loop (Not While)

While Loop with Ownership

While Loop and Mutable Variables

Using While with Collections

When Should You Use While?

Example – Guessing Game Pattern

Nested While Loops

Common Beginner Mistakes

While vs For Loop in Rust

Safety in Rust While Loops

Best Practices

Real-World Example – Countdown Timer

Frequently Asked Questions (FAQs)

1. What is a while loop in Rust?

2. What is the difference between while and loop?

3. Can a while loop return a value?

4. When should I use while instead of for?

5. Can while loops cause infinite loops?

Conclusion

You may also like...

Rust Tutorial

Rust Data Structures

Rust while Loops

Rust while Loop – Complete Beginner Guide

What Is a while Loop in Rust?

Basic Example – Counting with While

How while Loop Works Internally

Infinite While Loop

Breaking Out of a Loop

Skipping Iterations with continue

While vs Loop in Rust

Returning Values from loop (Not While)

While Loop with Ownership

While Loop and Mutable Variables

Using While with Collections

When Should You Use While?

Example – Guessing Game Pattern

Nested While Loops

Common Beginner Mistakes

While vs For Loop in Rust

Safety in Rust While Loops

Best Practices

Real-World Example – Countdown Timer

Frequently Asked Questions (FAQs)

1. What is a while loop in Rust?

2. What is the difference between while and loop?

3. Can a while loop return a value?

4. When should I use while instead of for?

5. Can while loops cause infinite loops?

Conclusion

You may also like...

Rust Output

Rust for Loop

Rust Borrowing and References

Rust Tutorial

Rust Data Structures

Rust `while` Loop – Complete Beginner Guide

What Is a `while` Loop in Rust?

How `while` Loop Works Internally