Ruby:在每个,map,inject,each_with_index和each_with_object之间进行选择

Question

当我多年前开始编写Ruby时,我花了一些时间来理解每个和地图之间的区别.当我发现所有其他Enumerable和Array方法时,情况会变得更糟.

在官方文档和许多 StackOverflow 问题的帮助下,我慢慢开始了解这些方法的作用.

以下是让我更长时间理解的内容:

• 我为什么要使用一种方法？
• 有没有指导方针？

我希望这个问题不是重复的:我对"为什么？"更感兴趣.比"什么？" 或"如何？",我认为它可以帮助Ruby新人.

Answer 1

更多的答案:博士回答:

如何在每个,map,inject,each_with_index和each_with_object之间进行选择？

• 使用#each当你想"通用"的迭代和不关心结果.示例 - 您有数字,您想要打印每个单独数字的绝对值:

  numbers.each { |number| puts number.abs }
  

• 使用#map当你想要一个新的列表,其中每个元素以某种方式通过将原始的元素构成.示例 - 你有数字,你想得到他们的方块:

  numbers.map { |number| number ** 2 }
  

• 使用#inject时要整个列表某种程度上减少到一个单一的价值.示例 - 你有数字,你想得到他们的总和:

  numbers.inject(&:+)
  

• #each_with_index在相同的情况下使用#each,除了您还希望索引与每个元素:

  numbers.each_with_index { |number, index| puts "Number #{number} is on #{index} position" }
  

• 用途#each_with_object更有限.最常见的情况是,如果您需要类似的东西#inject,但想要一个新的集合(而不是奇异值),这不是原始的直接映射.示例 - 数字直方图(频率):

  numbers.each_with_object({}) { |number, histogram| histogram[number] = histogram[number].to_i.next }
  

Answer 2

我可以使用哪个对象？

首先，您正在使用的对象应该是Array、Hash、Set、Range或任何其他响应的对象each。如果没有，它可能会转换为可以的东西。例如，您不能each直接调用String，因为您需要指定是否要迭代每个字节、字符或行。

"Hello World".respond_to?(:each)
#=> false
"Hello World".each_char.respond_to?(:each) 
#=> true

我想对每个元素进行计算，就像 C 或 Java 中的 for 循环一样。

如果您想迭代每个元素，对其执行某些操作而不修改原始对象，则可以使用each. 请继续阅读，以便知道您是否真的应该这样做。

array = [1,2,3]

#NOTE: i is a bound variable, it could be replaced by anything else (x, n, element). It's a good idea to use a descriptive name if you can
array.each do |i|
  puts "La"*i
end
#=> La
#   LaLa
#   LaLaLa

它是最通用的迭代方法，您可以用它编写任何其他提到的方法。实际上，我们只会出于教学目的。如果您在代码中发现类似的模式，您可能可以将其替换为相应的方法。

使用它基本上永远不会错each，但它几乎从来都不是最好的选择。它很冗长，而且不符合 Ruby 风格。

请注意，each返回原始对象，但这很少（从不？）使用。逻辑发生在块内部，并且不应修改原始对象。

我唯一使用的时间each是：

• 当没有其他方法可以做到的时候。我对 Ruby 了解得越多，这种情况发生的次数就越少。
• 当我为不懂 Ruby、有一定编程经验（例如 C、Fortran、VBA）并希望理解我的代码的人编写脚本时。

我想从我的 String/Hash/Set/File/Range/ActiveRecord::Relation 中获取一个数组

就打电话吧object.to_a。

(1..10).to_a
#=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
"Hello world".each_char.to_a
#=> ["H", "e", "l", "l", "o", " ", "w", "o", "r", "l", "d"]
{:a => 1, :b => 2}.to_a
#=> [[:a, 1], [:b, 2]]
Movie.all.to_a #NOTE: Probably very inefficient. Try to keep an ActiveRecord::Relation as Relation for as long as possible.
#=> [Citizen Kane, Trois couleurs: Rouge, The Grapes of Wrath, ....

下面描述的一些方法（例如compact，uniq）仅为数组定义。

我想根据原始对象获得修改后的数组。

如果你想得到一个基于原始对象的数组，你可以使用map. 返回的对象将与原始对象具有相同的大小。

array = [1,2,3]

new_array = array.map do |i|
  i**2
end
new_array
#=> [1, 4, 9]

#NOTE: map is often used in conjunction with other methods. Here is the corresponding one-liner, without creating a new variable :
array.map{|i| i**2}
#=> [1, 4, 9]

# EACH-equivalent (For pedagogical purposes only):
new_array = []
array.each do |i|
  new_array << i**2
end
new_array
#=> [1, 4, 9]

返回的 Array 不会替换原始对象。

这种方法应用非常广泛。这应该是您之后学习的第一个each。

collect是 的同义词map。确保在您的项目中仅使用两者之一。

我想在原始哈希的基础上获得修改后的哈希。

如果你的原始对象是一个哈希，map无论如何都会返回一个数组。如果你想要一个哈希回：

hash = {a: 1, b: 2}
hash.map{|key, value| [key, value*2]}.to_h
#=> {:a=>2, :b=>4}

# EACH-equivalent
hash = {a: 1, b: 2}
new_hash = {}
hash.each do |key,value|
  new_hash[key]=value*2
end
new_hash
#=> {:a=>2, :b=>4}

我想过滤一些元素。

我想删除 nil 元素

你可以打电话compact。它将返回一个不包含 nil 元素的新数组。

array = [1,2,nil,4,5]

#NOTE: array.map{|i| i*2} Would raise a NoMethodError
array.compact
# => [1, 2, 4, 5]

# EACH-equivalent
new_array = []
array.each do |integer_or_nil|
  new_array << integer_or_nil unless integer_or_nil.nil?
end
new_array

我想编写一些逻辑来确定是否应将元素保留在新数组中

您可以使用select或reject。

integers = (1..10)
integers.select{|i| i.even?}
# => [2, 4, 6, 8, 10]
integers.reject{|i| i.odd?}
# => [2, 4, 6, 8, 10]

# EACH-equivalent
new_array = []
integers.each do |i|
    new_array << i if i.even?
end
new_array

我想从数组中删除重复的元素

您可以使用uniq：

letters = %w(a b a b c)
letters.uniq
#=> ["a", "b", "c"]

# EACH-equivalent
uniq_letters = []
letters.each do |letter|
  uniq_letters << letter unless uniq_letters.include?(letter)
end
uniq_letters

#TODO: Add find/detect/any?/all?/count
#TODO: Add group_by/sort/sort_by

我想迭代所有元素，同时从 0 计数到 n-1

您可以使用each_with_index：

letters = %w(a b c)
letters.each_with_index do |letter, i|
  puts "Letter ##{i} : #{letter}"
end
#=> Letter #0 : a
#   Letter #1 : b
#   Letter #2 : c

#NOTE: There's a nice Ruby syntax if you want to use each_with_index with a Hash
hash = {:a=>1, :b=>2}
hash.each_with_index{|(key,value),i| puts "#{i} : #{key}->#{value}"}
# => 0 : a->1
#    1 : b->2

# EACH-equivalent
i = 0
letters.each do |letter|
  puts "Letter ##{i} : #{letter}"
  i+=1
end

each_with_index返回原始对象。

我想迭代所有元素，同时在每次迭代期间设置一个变量并在下一次迭代中使用它。

您可以使用inject：

gauss = (1..100)
gauss.inject{|sum, i| sum+i}
#=> 5050
#NOTE: You can specify a starting value with gauss.inject(0){|sum, i| sum+i}

# EACH-equivalent
sum = 0
gauss.each do |i|
  sum = sum + i
end
puts sum

它返回上次迭代定义的变量。

reduce是同义词。与地图/收集一样，选择一个关键字并保留它。

我想迭代所有元素，同时保持每次迭代可用的变量。

您可以使用each_with_object：

letter_ids = (1..26)

letter_ids.each_with_object({}){|i,alphabet| alphabet[("a".ord+i-1).chr]=i}
#=> {"a"=>1, "b"=>2, "c"=>3, "d"=>4, "e"=>5, "f"=>6, "g"=>7, "h"=>8, "i"=>9, "j"=>10, "k"=>11, "l"=>12, "m"=>13, "n"=>14, "o"=>15, "p"=>16, "q"=>17, "r"=>18, "s"=>19, "t"=>20, "u"=>21, "v"=>22, "w"=>23, "x"=>24, "y"=>25, "z"=>26}

# EACH-equivalent
alphabet = {}
letter_ids.each do |i|
  letter = ("a".ord+i-1).chr
  alphabet[letter]=i
end
alphabet

它返回上次迭代修改的变量。请注意，与 相比，两个块变量的顺序是相反的inject。

如果您的变量是哈希，您可能应该更喜欢使用此方法进行注入，因为h["a"]=1返回 1，并且需要在注入块中再添加一行来返回哈希。

我想要一些尚未提及的东西。

那么使用起来可能没问题each;)

注意事项：

这是一项正在进行的工作，我很高兴收到任何反馈。如果它足够有趣并且适合一页，我可能会从中提取流程图。