Ruby Loops: Alternatives to a do...while Loop in Ruby

By the end of this page, you will understand how Ruby handles loops that must run at least once. You will learn Ruby's begin ... end while form, the common loop do pattern with break, and how to write cleaner input-reading loops without fake initial values.

In some languages, a do ... while loop runs the code block first and checks the condition afterward. This is useful when the loop body must execute at least one time.

Ruby does not use the exact do ... while syntax, but it does support the same idea through:

• begin ... end while
• loop do ... break
• reading input first, then checking whether to continue

This matters because many real programs need to:

• ask for user input at least once
• retry until valid input is entered
• keep processing until a stop condition appears

A common beginner mistake is forcing a normal while loop to behave like a post-condition loop by giving a variable a fake initial value. That works, but it is not the clearest Ruby style.

In Ruby, the more idiomatic solution is usually one of these:

begin
  # code runs first
end while condition

or:

loop do
  # code runs
  break if stop_condition
end

Both patterns avoid unnecessary placeholder values and express your intent more clearly.

Think of a normal while loop like a security guard standing before a door:

• The guard checks the condition first.
• If the condition fails, you never enter.

A post-condition loop is like a guard standing after the room:

• You always go in once.
• After that, the guard decides whether you can go around again.

Your input example fits the second model:

• ask for a name
• if it is empty, stop
• otherwise store it and repeat

So the important idea is not the exact words do ... while, but the behavior: run once, then decide whether to continue.

1. begin ... end while

Ruby supports a post-condition loop using begin ... end while.

people = []

begin
  info = gets.chomp
  people << Person.new(info) unless info.empty?
end while !info.empty?

Why this works

• begin ... end runs first
• while !info.empty? is checked after the block
• the loop stops when the user enters an empty string

2. loop do with break

This is often the most idiomatic Ruby approach.

people = []

loop do
  info = gets.chomp
  break if info.empty?

  people << Person.new(info)
end

Why many Ruby developers prefer this

• very readable
• no fake initial value needed
• stopping condition is easy to see

3. Simple example without

Consider this Ruby code:

names = []

loop do
  name = gets.chomp
  break if name.empty?
  names << name
end

Now imagine the user types:

Alice
Bob

Step-by-step

1. names = []

   • An empty array is created.

2. loop do

   • Ruby starts an infinite loop.
   • It will keep running until break is reached.

3. First iteration:

   • name = gets.chomp
   • User enters Alice
   • name is now "Alice"
   • break if name.empty?
   • "Alice".empty? is false, so continue
   • names << name

This pattern appears often in Ruby programs.

User input collection

emails = []

loop do
  email = gets.chomp
  break if email.empty?
  emails << email
end

Used in small CLI tools, setup scripts, or interview exercises.

Retry until valid input

age = nil

loop do
  print "Enter your age: "
  input = gets.chomp

  if input.match?(/^\d+$/)
    age = input.to_i
    break
  end

  puts "Please enter a valid number."
end

Used in terminal apps and admin scripts.

Reading lines until a sentinel value

lines = []

loop do
  line = gets.chomp
  break if line == "STOP"
  lines << line
end

Useful when processing text input until a special command appears.

Menu-driven programs

loop do
  puts "1. Add"
  puts "2. Exit"
  choice = gets.chomp

    choice == 
  puts 

In real Ruby projects, developers usually pick the loop form that best matches the task.

Common pattern: guard clause with break

loop do
  input = gets.chomp
  break if input.empty?

  process(input)
end

This is clean because the stop condition is handled early.

Validation before object creation

users = []

loop do
  name = gets.chomp.strip
  break if name.empty?

  users << User.new(name: name)
end

This avoids creating invalid objects from empty input.

Using until for opposite logic

Sometimes Ruby code expresses the condition in reverse:

begin
  input = gets.chomp
  puts "You typed: #{input}"
end until input == "quit"

This works, but many teams still prefer loop do plus break because it is straightforward.

1. Using a fake initial value just to start the loop

This works, but it is usually less clear:

info = "a"
while !info.empty?
  info = gets.chomp
end

Better

loop do
  info = gets.chomp
  break if info.empty?
end

2. Creating objects before checking for empty input

Broken version:

loop do
  info = gets.chomp
  people << Person.new(info)
  break if info.empty?
end

Problem

This creates Person.new("") when the user presses Enter.

Better

loop do
  info = gets.chomp
  break if info.empty?
  people << Person.new(info)
end

3. Confusing not with

Post-condition loops in Ruby

Ruby does not use do ... while

Use one of these instead:

begin
  # code
end while condition

loop do
  # code
  break if condition
end

Best pattern for user input

items = []

loop do
  input = gets.chomp
  break if input.empty?
  items << input
end

Useful rules

• while checks the condition first
• begin ... end while checks after running once
• loop do runs forever until break
• use break to stop a loop do
• use next to skip to the next iteration

Is there a do ... while loop in Ruby?

Not with that exact syntax. Ruby uses begin ... end while for post-condition loops.

What is the Ruby equivalent of do ... while?

The closest equivalent is:

begin
  # code
end while condition

Many Ruby developers also use loop do with break.

Which is more idiomatic in Ruby: begin ... end while or loop do?

Both are valid, but loop do with break is more commonly seen in Ruby code.

Why not just use while?

A while loop checks the condition before the first iteration. If you need the loop body to run at least once, while alone is awkward.

Why should I use chomp with ?

while loop

Used for pre-condition looping when the condition should be checked before the first iteration.

until loop

A Ruby loop that continues until a condition becomes true.

break

Used to exit a loop early, especially with loop do.

next

Skips the rest of the current iteration and continues with the next one.

gets and chomp

Essential for reading clean user input from the terminal.

empty?

Checks whether a string or collection has no content.

guard clauses

A common pattern for handling stop conditions early and keeping code readable.