正确的方式是你觉得最舒服的方式，是你想让它做的方式。在编程中，很少有一种“正确”的方法来做事情，更多的是有多种方法可供选择。

如果你对某种做事方式感到舒服，那就去做，除非它不起作用——那么是时候寻找更好的方法了。

以下是你问题中列出的四个选项，按控制自由程度排列。您可能想要使用不同的方法，这取决于您需要什么。

简单回顾一下价值观: array.each 简单地看一下索引: array.each_index 遍历索引+索引变量: 对于数组中的I 控制循环计数+索引变量: array。length。乘以do | I |

我一直在尝试使用散列构建菜单(在Camping和Markaby中)。

每个项目都有两个元素:一个菜单标签和一个URL，所以哈希似乎是正确的，但“Home”的“/”URL总是出现在最后(正如你所期望的哈希)，所以菜单项出现的顺序是错误的。

使用带有each_slice的数组来完成这项工作:

['Home', '/', 'Page two', 'two', 'Test', 'test'].each_slice(2) do|label,link|
   li {a label, :href => link}
end

为每个菜单项添加额外的值(例如CSS ID名)只是意味着增加切片值。就像一个散列，但是组由任意数量的项组成。完美的。

所以这只是为了感谢你无意中暗示了一个解决方案!

很明显，但值得说明:我建议检查数组的长度是否能被切片值整除。

The other answers are just fine, but I wanted to point out one other peripheral thing: Arrays are ordered, whereas Hashes are not in 1.8. (In Ruby 1.9, Hashes are ordered by insertion order of keys.) So it wouldn't make sense prior to 1.9 to iterate over a Hash in the same way/sequence as Arrays, which have always had a definite ordering. I don't know what the default order is for PHP associative arrays (apparently my google fu isn't strong enough to figure that out, either), but I don't know how you can consider regular PHP arrays and PHP associative arrays to be "the same" in this context, since the order for associative arrays seems undefined.

因此，Ruby的方式对我来说似乎更加清晰和直观。：）

试图对数组和哈希始终如一地做同样的事情可能只是代码的味道，但是，冒着被打上令人讨厌的半猴子补丁的风险，如果您正在寻找一致的行为，这能做到吗?：

class Hash
    def each_pairwise
        self.each { | x, y |
            yield [x, y]
        }
    end
end

class Array
    def each_pairwise
        self.each_with_index { | x, y |
            yield [y, x]
        }
    end
end

["a","b","c"].each_pairwise { |x,y|
    puts "#{x} => #{y}"
}

{"a" => "Aardvark","b" => "Bogle","c" => "Catastrophe"}.each_pairwise { |x,y|
    puts "#{x} => #{y}"
}

我不是说数组-> |值，索引|和哈希-> |键，值|不是疯狂的(见Horace Loeb的评论)，但我是说有一种理智的方式来期望这种安排。

当我处理数组时，我关注的是数组中的元素(而不是索引，因为索引是临时的)。方法是每个带索引，即每个+索引，或|每个，索引|，或|值，索引|。这也与索引被视为可选参数相一致，例如|值|相当于|值，index=nil|与|值一致，index|。

当我处理散列时，我通常更关注键而不是值，并且我通常按此顺序处理键和值，key => value或hash[key] = value。

如果需要鸭子类型，那么可以显式使用Brent Longborough所示的已定义方法，也可以使用maxhawkins所示的隐式方法。

Ruby就是让语言适应程序员，而不是让程序员适应语言。这就是为什么有这么多方法。思考一件事有很多种方式。在Ruby中，你选择最接近的代码，其余的代码通常会非常简洁。

至于最初的问题，“在Ruby中迭代数组的“正确”方法是什么?”，我认为核心方法(即没有强大的语法糖或面向对象的能力)是:

for index in 0 ... array.size
  puts "array[#{index}] = #{array[index].inspect}"
end

但是Ruby是关于强大的语法糖和面向对象的能力的，但无论如何，这里有等效的哈希值，键可以是有序的，也可以不是:

for key in hash.keys.sort
  puts "hash[#{key.inspect}] = #{hash[key].inspect}"
end

所以，我的回答是，“在Ruby中迭代数组的“正确”方式取决于你(即程序员或编程团队)和项目。”更好的Ruby程序员会做出更好的选择(选择哪种语法能力和/或哪种面向对象的方法)。优秀的Ruby程序员会继续寻找更多的方法。

---

现在，我想问另一个问题，“在Ruby中反向迭代Range的“正确”方法是什么?”!(这个问题是我如何来到这个页面的。)

(对于远期)这样做很好:

(1..10).each{|i| puts "i=#{i}" }

but I don't like to do (for backward):

(1..10).to_a.reverse.each{|i| puts "i=#{i}" }

其实，我并不介意这么做，但当我在逆向教学时，我想向我的学生展示一个漂亮的对称(即差别最小，例如只添加反向，或步长-1，但不修改其他任何东西)。 你可以这样(为了对称):

(a=*1..10).each{|i| puts "i=#{i}" }

and

(a=*1..10).reverse.each{|i| puts "i=#{i}" }

我不太喜欢，但你做不到

(*1..10).each{|i| puts "i=#{i}" }
(*1..10).reverse.each{|i| puts "i=#{i}" }
#
(1..10).step(1){|i| puts "i=#{i}" }
(1..10).step(-1){|i| puts "i=#{i}" }
#
(1..10).each{|i| puts "i=#{i}" }
(10..1).each{|i| puts "i=#{i}" }   # I don't want this though.  It's dangerous

你最终可以做到

class Range

  def each_reverse(&block)
    self.to_a.reverse.each(&block)
  end

end

但我想教纯Ruby，而不是面向对象的方法(目前)。我想向后迭代:

不需要创建数组(考虑0..1000000000) 适用于任何范围(例如字符串，而不仅仅是整数) 无需使用任何额外的面向对象功能(即无需修改类)

我相信如果不定义一个pred方法，这是不可能的，这意味着修改Range类来使用它。如果您能做到这一点，请让我知道，否则确认不可能将不胜感激，尽管这将是令人失望的。也许Ruby 1.9解决了这个问题。

(感谢您花时间阅读本文。)