escaping the .each { } iteration early in Ruby

Question

code:

 c = 0  
 items.each { |i|  
   puts i.to_s    
   # if c > 9 escape the each iteration early - and do not repeat  
   c++  
 }  

I want to grab the first 10 items then leave the "each" loop.

What do I replace the commented line with? is there a better approach? something more Ruby idiomatic?

Marsh

I suggest nimrodm's answer that uses take: #1568788 – Hereof

Answer 1

While the break solution works, I think a more functional approach really suits this problem. You want to take the first 10 elements and print them so try

items.take(10).each { |i| puts i.to_s }

Superbomb

Shorter: puts items.take(10) – Hurtle

I tried Googling for 'ruby take method' just now and couldn't find a reference to what module take is in. Where is it in the API? – Garnishee

I suppose I need to upgrade my Ruby version: Nothing known about Array#take – Monk

Or ri Enumerable#take, I suppose. Note that it appears to be new in Ruby 1.9. I get a no method error in Ruby 1.8.6 trying it. – Hurtle

Array#take is present in Ruby 1.8.7 and up. – Volvulus

Ruby 1.8.7 has it, otherwise you can monkey-patch it into Array: class Array; def take(how_many); self[0..how_many]; end. AFAIK this is simple and reliable. – Hereof

ahhh. I'm down with FP. "You know me!". +1 and answer. I like this better than previous answer. But good to know the break option is there. break lines are easy to comment out during testing. – Marsh

Answer 2

There is no ++ operator in Ruby. It's also convention to use do and end for multi-line blocks. Modifying your solution yields:

c = 0  
items.each do |i|  
  puts i.to_s    
  break if c > 9
  c += 1 
end

Or also:

items.each_with_index do |i, c|  
  puts i.to_s    
  break if c > 9
end

See each_with_index and also Programming Ruby Break, Redo, and Next.

Update: Chuck's answer with ranges is more Ruby-like, and nimrodm's answer using take is even better.

Garnishee

Thanks. Answer and +1. Wow I was way off on the initial syntax. – Marsh

You weren't far off, really: the only invalid part of your answer was the ++. Curly braces for blocks will work, it's just not preferred for multi-line blocks; see #533508 – Garnishee

I like your first solution because if you want to loop over 100 items every time but only take out 10 conditionally you can increment the counter independently. – Chilly

Answer 3

break works for escaping early from a loop, but it's more idiomatic just to do items[0..9].each {|i| puts i}. (And if all you're doing is literally printing the items with no changes at all, you can just do puts items[0..9].)

Volvulus

I'd have written it as: puts items[0..9].join("\n") – Youngman

Answer 4

Another variant:

puts items.first(10)

Note that this works fine with arrays of less than 10 items:

>> nums = (1..5).to_a
=> [1, 2, 3, 4, 5]
>> puts nums.first(10)
1
2
3
4
5

(One other note, a lot of people are offering some form of puts i.to_s, but in such a case, isn't .to_s redundant? puts will automatically call .to_s on a non-string to print it out, I thought. You would only need .to_s if you wanted to say puts 'A' + i.to_s or the like.)

Hurtle

Answer 5

Another option would be

items.first(10).each do |i|
  puts i.to_s
end

That reads a little more easily to me than breaking on an iterator, and first will return only as many items as available if there aren't enough.

Oca

Answer 6

Does this look like what you want?

10.times { |i|
  puts items[i].to_s
}

Monk

That would work, but I won't always be sure that the source has at least 10 items. – Marsh

Ah. You can add break if items[i] == nil but at this point each_with_index is looking like what you should be using. – Monk

Answer 7

items.each_with_index { |i, c| puts i and break if c <= 9 }

Masker

That will break after the first item. – Volvulus

Not really, how did u test it? – Masker

@Khelll: is this due to lazy evaluation of and? It works, but it's a bit too clever for me. My brain keeps wanting >= since I see "and break if" together. – Hurtle

Ok, now I see it: puts returns nil when it works. Thus, as long as the index is equal to or less than 9, the puts happens, nil is returned and the second half of the and is not evaluated. When the index hits 10, the puts doesn't happen and the second half of the and gets evaluated. At that point, boom: break. – Hurtle

OK, I had it backwards before, but it's still wrong: This never breaks. Look at it like this: if c <= 9; puts i; break; end. The and break is never executed because puts i is always nil and once c>9, the entire body of the if-statement is no longer executed. Replace the break with (puts "YOU WON'T SEE THIS") if you want to prove that that branch is never reached. – Volvulus

@Chuck: thanks for one more round. @Khelll: I think we've proven that it doesn't read very naturally. – Hurtle

Answer 8

It was asked:

I want to grab the first 10 items then leave the "each" loop.

Use throw and catch to accomplish this, with few changes to the example:

catch(:done) do
    c = 0
    collected = []
    items.each do |item|
        collected << item
        throw(:done, collected) if c == 9 # started at 0
        c += 1
    end
    collected # if the list is less than 10 long, return what was collected
end

Simply throw the label :done with collected and the catch which is waiting for :done will return collected.

And to "ruby" this up a bit:

catch(:done) do
    items.inject([]) do |collected, item|
        throw(:done, collected) if collected.size == 10
        collected << item # collected gets returned here and populates the first argument of this block
    end
end

I do not know why some people refuse to use inject and use reduce instead (they are equivalent) when clearly the empty array given to inject([]) is being injected with items! Anyhow, the inject will return collected if there are less than 10 items.

Most answers are trying to answer what might be the intent of the question instead of what was asked and items.take(10) does make perfect sense in that case. But I can imagine wanting to grab the first items that fit within my $100 budget. Then you can simply:

catch(:done) do
    items.inject({items: [], budget: 100}) do |ledger, item|
        remainder = ledger[:budget] - item.price
        if remainder < 0
            throw(:done, ledger)
        else
            ledger.tap do |this|
                this[:items] << item
                this[:budget] = remainder
            end # tap just returns what is being tapped into, in this case, ledger
        end
    end
end

Copt

You took a simple question and gave a really complicated answer. There's no need to use throw and catch here or turn this into 13 lines of deeply nested code. Keep it simple. – Persas

My answer is 6 lines, it shows an alternative way to escape an each loop which was asked, it is nested one level deeper than most of the answers. My hope in leaving this answer was to show how to alternatively get out of a loop taking advantage of this simple context. If you had actually read my post, my 13 lines of code is a more complex answer to a more complex example I posed in my answer. I apologize in advance for having too many words in this response. – Copt