I would like to use something like reverse_each_with_index on an array.
Example:
array.reverse_each_with_index do |node,index|
puts node
puts index
end
I see that Ruby has each_with_index but it doesn’t seem to have an opposite. Is there another way to do this?
If you want the real index of the element in the array you can do this
['Seriously', 'Chunky', 'Bacon'].to_enum.with_index.reverse_each do |word, index|
puts "index #{index}: #{word}"
end
Output:
index 2: Bacon
index 1: Chunky
index 0: Seriously
You can also define your own reverse_each_with_index method
class Array
def reverse_each_with_index &block
to_enum.with_index.reverse_each &block
end
end
['Seriously', 'Chunky', 'Bacon'].reverse_each_with_index do |word, index|
puts "index #{index}: #{word}"
end
An optimized version
class Array
def reverse_each_with_index &block
(0...length).reverse_each do |i|
block.call self[i], i
end
end
end
(array.size - 1).downto(0) that lets you delete_at(index) during enumeration. The other solutions at the time of me writing this will not produce stable indices.First reverse the array, and then use each_with_index:
array.reverse.each_with_index do |element, index|
# ...
end
Although, indexes will go from 0 to length - 1, not the other way around.
Without copying array:
(array.size - 1).downto(0) do |index|
node = array[index]
# ...
end
Well since Ruby always likes to give you options you can not only do:
arr.reverse.each_with_index do |e, i|
end
but you can also do:
arr.reverse_each.with_index do |e, i|
end
.reverse_each.with_index to be faster, since .reverse_each is faster than .reverse.each. I would therefore use .reverse_each.with_index and reverse the indexes myself, or use the reversed index as a negative array lookup. Although brief experimentation did not show a big difference in my irb.
arr.reverse_each.with_index do |e, i| end doesn't work for what the op is asking for. This will yield the forward ordered indexes [0,1,2 etc]Simply
arr.reverse.each_with_index do |node, index|
The real correct answer is like the following.
a = ['a', 'b', 'c']
a.each_with_index.reverse_each {|e, i|
p [i, e]
}
This gives the following output.
[2, "c"]
[1, "b"]
[0, "a"]
As a side note, this has worked on Ruby 1.9.3(around 2011) and later at least.
in my usecase I wanted to iterate backwards using negative indexes
a = %w[a b c]
(1..a.size).each {|i| puts "-#{i}: #{a[-i]}"}
# => -1: c
# => -2: b
# => -3: a
reverse_each_with_index, or want to implement one that has a certain function? Different portions of your question imply one or the other.