last modified April 27, 2025
This tutorial explains how to use Ruby's redo keyword. It restarts
the current iteration of a loop without checking the loop condition.
The redo keyword causes the current loop iteration to restart. Unlike
next, it doesn't evaluate loop conditions or move to the next item.
redo is useful when you need to retry an operation without
progressing loop state. It works with while, until,
for, and iterator methods.
This simple example demonstrates the basic behavior of redo. The
loop restarts when a condition is met.
count = 0
while count < 5
count += 1
puts "Count: #{count}"
if count == 3
puts "Redoing iteration"
redo
end
end
The loop would normally run 5 times, but the redo at count 3 causes
that iteration to restart. Notice the loop condition isn't rechecked.
redo is commonly used for input validation. This example keeps
asking for input until valid data is provided.
3.times do |i|
print "Enter a positive number: "
input = gets.chomp.to_i
if input <= 0
puts "Invalid input! Try again."
redo
end
puts "You entered: #{input}"
end
The redo restarts the current iteration if input is invalid. The
loop counter doesn't increment until valid input is received.
In nested loops, redo affects only the innermost loop. This example
shows its behavior in nested structures.
outer = 0
inner = 0
while outer < 2
outer += 1
puts "Outer: #{outer}"
while inner < 3
inner += 1
puts " Inner: #{inner}"
if inner == 2
puts " Redoing inner loop"
redo
end
end
inner = 0
end
The redo only affects the inner loop. The outer loop continues
normally after the inner loop completes all iterations.
This example implements retry logic for an unreliable operation using
redo. It retries failed operations immediately.
attempts = 0
5.times do |i|
attempts += 1
puts "Attempt #{attempts} (iteration #{i + 1})"
# Simulate random failure
if rand < 0.4
puts "Operation failed! Retrying..."
redo
end
puts "Operation succeeded"
end
Each failure triggers a redo, restarting the current iteration.
The loop counter only increments after successful operations.
This example contrasts redo with next to highlight
their different behaviors in loop control.
puts "Using redo:"
3.times do |i|
puts "Start iteration #{i}"
if i == 1
puts "Redoing..."
redo
end
puts "End iteration #{i}"
end
puts "\nUsing next:"
3.times do |i|
puts "Start iteration #{i}"
if i == 1
puts "Skipping..."
next
end
puts "End iteration #{i}"
end
redo restarts the current iteration, while next skips
to the next iteration. Notice how the output differs between the two cases.
redo works with until loops similarly to
while loops. This example shows its behavior in negative logic.
value = 0
until value > 3
value += 1
puts "Value: #{value}"
if value == 2
puts "Redoing until check"
redo
end
end
The redo restarts the iteration without re-evaluating the
until condition. The loop continues until the condition becomes
true.
This advanced example shows redo behavior in a method that yields
to a block. The redo affects the block's execution.
def retry_operation
attempts = 0
3.times do |i|
attempts += 1
puts "Attempt #{attempts}"
yield i
if attempts < 3
puts "Retrying..."
redo
end
end
end
retry_operation do |i|
puts "Block execution #{i}"
raise "Error" if i == 0 && attempts < 2
rescue
puts "Rescued error"
end
The redo inside the method restarts the block execution. Combined
with error handling, this creates powerful retry logic.
This tutorial covered Ruby's redo keyword with practical examples
showing input validation, retry logic, and loop control patterns.
My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.
List all Ruby tutorials.