就其所有缺陷而言，PHP在这方面表现得相当不错。数组和哈希表之间没有区别（也许我很幼稚，但这对我来说显然是正确的），要遍历它们，只需执行以下操作
foreach (array/hash as $key => $value)
在Ruby中，有许多种方法可以做这样的事情：
array.length.times do |i|
end
array.each
array.each_index
for i in array
哈希更合理，因为我总是使用它们
hash.each do |key, value|
为什么我不能对数组做同样的操作呢？如果我只想记住一个方法，我猜我可以使用 each_index（因为它同时提供索引和值），但是每次都要写 array[index] 而不是直接用 value 很麻烦。
哦，对了，我忘了 array.each_with_index。然而，这个方法很糟糕，因为它返回的参数是 |value, key|，而 hash.each 返回的是 |key, value|！这不是很疯狂吗？
这将遍历所有元素：
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
从你的问题中，我不太确定你具体需要哪一个。
array.each { puts _1 }。 - Chris我认为没有一种正确的方法。有很多不同的迭代方式，每一种都有其自己的特点。
each 很适合许多用途，因为通常并不关心索引。each_with_index 类似于 Hash＃each - 您可以获取值和索引。each_index - 仅限索引。 我不经常使用此方法。 相当于 "length.times"。map 是另一种迭代方式，当您想将一个数组转换为另一个数组时很有用。select 是选择子集时要使用的迭代器。inject 对于生成总和或乘积，或收集单个结果非常有用。可能看起来需要记住很多，但别担心，您可以在不知道它们所有方法的情况下进行编码。但是，随着您开始学习和使用不同的方法，您的代码将变得更加清晰简洁，您将朝着Ruby掌握的方向前进。
Array -> |value,index| 和 Hash -> |key,value| 这样的写法不合理（可以看 Horace Loeb 的评论），但我认为有一种更加合理的写法。|value,index|。这也与将索引视为可选参数相符，例如 |value| 相当于 |value,index=nil|，这与 |value,index| 是一致的。key => value，要么是 hash[key] = value。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
(1..10).each{|i| puts "i=#{i}" }
但我不喜欢做（向后）：
(1..10).to_a.reverse.each{|i| puts "i=#{i}" }
嗯，我并不介意这样做，但当我倒着教学时，我想向我的学生展示一个漂亮的对称性（即最小差异，例如只添加一个反转或步骤-1，但不修改任何其他内容）。 您可以执行以下操作（以实现对称性）：
(a=*1..10).each{|i| puts "i=#{i}" }
并且
(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
pred方法，这意味着修改Range类来使用它。如果您能够做到这一点，请让我知道，否则请确认无法实现，尽管这会令人失望。也许Ruby 1.9可以解决这个问题。1.upto(10) do |i| puts i end 和 10.downto(1) do puts i end 这样的代码可以呈现出你想要的对称性。希望这有所帮助。不确定是否适用于字符串等其他情况。 - Suren[*1..10].each{|i| puts "i=#{i}" }。 - Hauleth当需要两者时，请使用each_with_index。
ary.each_with_index { |val, idx| # ...
以下是您问题中列出的四个选项，按控制自由度排列。根据您的需求，您可能希望使用不同的选项。
仅遍历值：
array.each
只需简单地遍历索引：
array.each_index
通过索引和索引变量进行遍历：
for i in array
控制循环次数 + 索引变量：
array.length.times do | i |
试图通过数组和哈希表实现相同的功能可能只是代码异味，但是，为了保持一致的行为，如果你想要实现这个效果，这个方法有用吗？
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}"
}
['Home', '/', 'Page two', 'two', 'Test', 'test'].each_slice(2) do|label,link|
li {a label, :href => link}
end
为每个菜单项添加额外值（例如，像CSS的ID名称）只意味着增加片段值。因此，就像哈希一样，但是组包含任意数量的项目。完美。
所以这只是想说感谢您无意中暗示了解决方案！
显而易见，但值得说明的是：建议检查数组长度是否可被片段值整除。
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.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]]
a = [ "a", "b", "c" ]
a.each_index {|x| print x, " -- " }
生成：
0 -- 1 -- 2 --
each_with_index未在文档中出现的原因是因为它由Enumerable模块提供。 - ihaztehcodez
array#each_with_index使用|value, key|是因为方法名暗示了顺序，而hash#each使用的顺序模仿了hash[key] = value语法？ - Benjineer