这将遍历所有元素:

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。

ary.each_with_index { |val, idx| # ...

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

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

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

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的方式对我来说似乎更加清晰和直观。：）

如果使用可枚举的mixin(如Rails所做的那样)，则可以执行与列出的php代码片段类似的操作。只需使用each_slice方法并将散列平铺。

require 'enumerator' 

['a',1,'b',2].to_a.flatten.each_slice(2) {|x,y| puts "#{x} => #{y}" }

# is equivalent to...

{'a'=>1,'b'=>2}.to_a.flatten.each_slice(2) {|x,y| puts "#{x} => #{y}" }

更少的猴子补丁需要。

但是，当您有一个递归数组或数组值的散列时，这确实会导致问题。在ruby 1.9中，这个问题通过flatten方法的参数来解决，该方法指定递归的深度。

# Ruby 1.8
[1,2,[1,2,3]].flatten
=> [1,2,1,2,3]

# Ruby 1.9
[1,2,[1,2,3]].flatten(0)
=> [1,2,[1,2,3]]

至于这是否是代码气味的问题，我不确定。通常当我不得不竭尽全力迭代某些内容时，我就会后退一步，意识到我在错误地处理问题。

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

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

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

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

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

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

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

在Ruby 2.1中，each_with_index方法被移除。 相反，您可以使用each_index

例子:

a = [ "a", "b", "c" ]
a.each_index {|x| print x, " -- " }

生产:

0 -- 1 -- 2 --

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

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

使用相同的方法迭代数组和散列是有意义的，例如处理嵌套的散列和数组结构，通常由解析器产生，读取JSON文件等。

一个尚未被提及的聪明方法是如何在标准库扩展的Ruby Facets库中实现它。从这里开始:

class Array

  # Iterate over index and value. The intention of this
  # method is to provide polymorphism with Hash.
  #
  def each_pair #:yield:
    each_with_index {|e, i| yield(i,e) }
  end

end

已经有哈希#each_pair，哈希#each的别名。所以在这个补丁之后，我们也有了数组#each_pair，并且可以互换地使用它来遍历哈希和数组。这修复了OP观察到的array# each_with_index与Hash#each相比块参数颠倒的疯狂。使用示例:

my_array = ['Hello', 'World', '!']
my_array.each_pair { |key, value| pp "#{key}, #{value}" }

# result: 
"0, Hello"
"1, World"
"2, !"

my_hash = { '0' => 'Hello', '1' => 'World', '2' => '!' }
my_hash.each_pair { |key, value| pp "#{key}, #{value}" }

# result: 
"0, Hello"
"1, World"
"2, !"