How to Skip an Iteration in Ruby .each: Using next Instead of continue

By the end of this page, you will understand how Ruby skips the current iteration of a loop using next, especially inside .each blocks. You will also see how next compares with break, redo, and loop control in other languages, along with practical examples and common mistakes.

In many programming languages, continue means: stop the current loop iteration and move to the next one.

Ruby does not use the keyword continue. Instead, Ruby uses next for this purpose.

When you are looping with .each, next immediately ends the current block execution and moves to the next element.

Example:

[1, 2, 3, 4].each do |number|
  next if number.even?
  puts number
end

Output:

1
3

Here is what happens:

• 1 is not even, so it gets printed.
• 2 is even, so next skips the rest of that iteration.
• 3 is printed.
• 4 is skipped.

Think of an .each loop like a teacher calling students one by one.

• next means: skip this student and call the next one
• break means: stop calling students entirely
• normal execution means: process this student as usual

So if Ruby is in the middle of handling one item and you say next, Ruby drops the rest of that item's instructions and moves on immediately.

The basic syntax is:

collection.each do |item|
  next if condition

  # code that runs only when condition is false
end

Example 1: Skip even numbers

numbers = [1, 2, 3, 4, 5]

numbers.each do |number|
  next if number.even?
  puts number
end

Output:

1
3
5

next if number.even? means:

• if the number is even, skip the rest of the block
• otherwise, continue executing the block

Example 2: Skip blank names

names = ["Alice", "", "Bob", nil, "Carol"]

names.each do |name|
    name.? || name.empty?
  puts 

Consider this example:

numbers = [1, 2, 3]

numbers.each do |n|
  puts "Start #{n}"
  next if n == 2
  puts "End #{n}"
end

Output:

Start 1
End 1
Start 2
Start 3
End 3

Step by step:

1. numbers contains [1, 2, 3].
2. Ruby starts .each and takes the first value, 1.
3. It prints Start 1.
4. n == 2 is false, so next does not run.
5. It prints End 1.

next is useful whenever some items in a collection should not be processed.

Filtering invalid data

rows.each do |row|
  next if row[:email].nil? || row[:email].empty?
  send_welcome_email(row[:email])
end

Ignoring admin-only restricted actions

users.each do |user|
  next unless user.admin?
  puts "Granting access to #{user.name}"
end

Skipping failed API responses

responses.each do |response|
  next unless response[:status] == 200
  process_data(response[:body])
end

Ignoring comments or blank lines in a file

File.readlines().each  ||
  line = line.strip
    line.empty? || line.start_with?()
  puts 

In real projects, developers often use next as a guard clause inside loops.

1. Early skip for invalid input

records.each do |record|
  next unless record.valid?
  save_record(record)
end

This keeps the main logic less nested.

2. Permission checks

tasks.each do |task|
  next unless current_user.can_edit?(task)
  update_task(task)
end

3. Skipping expensive work

images.each do |image|
  next if image.processed?
  generate_thumbnail(image)
end

4. Combining with logging

items.each do |item|
  if item.nil?
    warn "Skipping nil item"
    next
  end

  process(item)
end

Mistake 1: Using continue in Ruby

Broken code:

[1, 2, 3].each do |n|
  continue if n == 2
  puts n
end

Ruby does not have continue.

Correct code:

[1, 2, 3].each do |n|
  next if n == 2
  puts n
end

Mistake 2: Confusing next with break

Broken idea:

[1, 2, 3, 4].each do |n|
  break if n == 2
  puts n
end

Output:

next vs break

# Skip current iteration
next

# Skip current iteration when condition is true
next if condition

# Skip unless condition is true
next unless condition

Common patterns

items.each do |item|
  next if item.nil?
  process(item)
end

items.each do |item|
  next unless item.valid?
  process(item)
end

Loop control keywords

• next → skip current iteration
• break → stop the loop
• redo → repeat current iteration

Important rule

Ruby uses next, not continue.

With map

What is the Ruby equivalent of continue?

Ruby uses next instead of continue.

Can I use next inside .each?

Yes. next works inside .each blocks to skip the current iteration.

What is the difference between next and break in Ruby?

next skips one iteration. break stops the entire loop.

Does next work only with .each?

No. It also works in other Ruby looping constructs and enumerable blocks.

Why does map return nil when I use next?

Because map expects one output value for each input item. If next has no value, that iteration becomes .

• each — the basic Ruby iterator for processing items one by one.
• break — used to stop a loop completely.
• redo — repeats the current iteration without moving to the next item.
• map — transforms a collection into a new collection.
• select — filters items you want to keep.
• reject — filters items you want to remove.
• filter_map — combines filtering and transformation in one step.
• guard clauses — a style that uses early exits like next to reduce nesting.