Tell the End of a .Each Loop in Ruby

Tell the end of a .each loop in ruby

users.each_with_index do |u, index|
  # some code
  if index == users.size - 1
    # code for the last user
  end
end

escaping the .each { } iteration early in Ruby

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 }

Ruby Last Iteration of Each Loop

You can use each_with_index that gives you the current element and the index. In this way, you can compare the size of the array with the current element.

However, I don't like this approach. In your case that's not clean because you are filtering records inside the loop. I would rather filter the records, then only loop valid records.

file.puts @headers.
    # keep only elements where the condition matches
    select { |header| header[:table_id] == table[:id] }.
    # convert each element into a line
    map { |header| "`#{table[:source_database]}`.`#{table[:current_name]}`.`#{header[:current_name]}` AS `#{header[:magi_name]}`" }.
    # merge everything into a single string
    join(", ")

Finding out current index in EACH loop (Ruby)

X.each_with_index do |item, index|
  puts "current_index: #{index}"
end

In Ruby, how do I skip a loop in a .each loop, similar to 'continue'

Use next:

(1..10).each do |a|
  next if a.even?
  puts a
end

prints:

1
3   
5
7
9

For additional coolness check out also redo and retry.

Works also for friends like times, upto, downto, each_with_index, select, map and other iterators (and more generally blocks).

For more info see http://ruby-doc.org/docs/ProgrammingRuby/html/tut_expressions.html#UL.

How to break out from a ruby block?

Use the keyword next. If you do not want to continue to the next item, use break.

When next is used within a block, it causes the block to exit immediately, returning control to the iterator method, which may then begin a new iteration by invoking the block again:

f.each do |line|              # Iterate over the lines in file f
  next if line[0,1] == "#"    # If this line is a comment, go to the next
  puts eval(line)
end

When used in a block, break transfers control out of the block, out of the iterator that invoked the block, and to the first expression following the invocation of the iterator:

f.each do |line|             # Iterate over the lines in file f
  break if line == "quit\n"  # If this break statement is executed...
  puts eval(line)
end
puts "Good bye"              # ...then control is transferred here

And finally, the usage of return in a block:

return always causes the enclosing method to return, regardless of how deeply nested within blocks it is (except in the case of lambdas):

def find(array, target)
  array.each_with_index do |element,index|
    return index if (element == target)  # return from find
  end
  nil  # If we didn't find the element, return nil
end

whole RUBY hashmap printed out after .each loop

You're getting this because you've included a = sign in your .each loop. When you write <%= you're telling the .erb interpreter that what's inside of the brackets is going to get displayed on the page. Change the line

<%= @tag_color_hash.each do |tag, color| %>

to

<% @tag_color_hash.each do |tag, color| %>

and your problem should get fixed. Here's a link to a useful StackOverflow answer.

Magic First and Last Indicator in a Loop in Ruby/Rails?

You could grab the first and last elements and process them differently, if you like.

first = array.shift
last = array.pop
process_first_one
array.each { |x| process_middle_bits }
process_last_one

---

Related Topics