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

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

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

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

我不是说数组-> |值，索引|和哈希-> |键，值|不是疯狂的(见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解决了这个问题。

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

这将遍历所有元素:

array = [1, 2, 3, 4, 5, 6]
array.each { |x| puts x }

# Output:

1
2
3
4
5
6

这将遍历所有给你值和索引的元素:

array = ["A", "B", "C"]
array.each_with_index {|val, index| puts "#{val} => #{index}" }

# Output:

A => 0
B => 1
C => 2

从你的问题我不太确定你在找哪一个。

我认为没有唯一正确的方法。有许多不同的迭代方法，每种方法都有自己的细分市场。

对于许多用法，每个都足够了，因为我不经常关心索引。 each_ with _index的作用类似于Hash#each——你得到值和索引。 Each_index—只有索引。我不经常用这个。相当于"length.times"。 Map是迭代的另一种方式，当你想将一个数组转换为另一个数组时很有用。 Select是要选择子集时使用的迭代器。 Inject在生成总和或乘积或收集单个结果时很有用。

看起来要记住的东西太多了，但别担心，你不知道所有的单词也能应付过去。但是当您开始学习和使用不同的方法时，您的代码将变得越来越清晰，您将走上精通Ruby的道路。

我一直在尝试使用散列构建菜单(在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名)只是意味着增加切片值。就像一个散列，但是组由任意数量的项组成。完美的。

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

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