Ruby 枚举器链接

Question

在这个例子中，

[1, 2, 3].each_with_index.map{|i, j| i * j}
# => [0, 2, 6]

我的理解是，由于 each_with_index 枚举器链接到 map，map 的行为类似于 each_with_index block 内的索引，并返回一个新数组。

为此，

[1, 2, 3].map.each_with_index{|i, j| i * j}
# => [0, 2, 6] 

我不确定如何解释它。

在这个例子中，

[1, 2, 3, 4].map.find {|i| i == 2}
# => 2

我期望输出为 [2]，假设 map 链接到 find，并且 map 将返回一个新数组。

另外，我看到了这个:

[1, 2, 3, 4].find.each_with_object([]){|i, j| j.push(i)}
# => [1]

[1, 2, 3, 4].each_with_object([]).find{|i, j| i == 3}
# => [3, []]

你能告诉我如何解释和理解 Ruby 中的枚举器链吗？

Answer 1

您可能会发现将这些表达式分解并使用 IRB 或 PRY 来查看 Ruby 正在做什么很有用。让我们开始:

[1,2,3].each_with_index.map { |i,j| i*j }

让

enum1 = [1,2,3].each_with_index
  #=> #<Enumerator: [1, 2, 3]:each_with_index>

我们可以使用Enumerable#to_a (或 Enumerable#entries )将 enum1 转换为数组，以查看它将传递给下一个枚举器(或 block ，如果有的话)的内容:

enum1.to_a
  #=> [[1, 0], [2, 1], [3, 2]]

这并不奇怪。但是 enum1 没有 block 。相反，我们向它发送方法 Enumerable#map :

enum2 = enum1.map
  #=> #<Enumerator: #<Enumerator: [1, 2, 3]:each_with_index>:map>

您可能会认为这是一种“复合”枚举器。此枚举器确实有一个 block ，因此将其转换为数组将确认它将相同的元素传递到 block 中，因为 enum1 将具有:

enum2.to_a
  #=> [[1, 0], [2, 1], [3, 2]]

我们看到数组 [1,0] 是第一个元素 enum2 传递到 block 中。 “消除歧义”应用于此数组以将值分配给 block 变量:

i => 1
j => 0

也就是说，Ruby 正在设置:

i,j = [1,0]

我们现在可以通过向 each 方法发送 block 来调用 enum2:

enum2.each { |i,j| i*j }
  #=> [0, 2, 6]

接下来考虑:

[1,2,3].map.each_with_index { |i,j| i*j }

我们有:

enum3 = [1,2,3].map
  #=> #<Enumerator: [1, 2, 3]:map>
enum3.to_a
  #=> [1, 2, 3]
enum4 = enum3.each_with_index
  #=> #<Enumerator: #<Enumerator: [1, 2, 3]:map>:each_with_index>
enum4.to_a
  #=> [[1, 0], [2, 1], [3, 2]]
enum4.each { |i,j| i*j }
  #=> [0, 2, 6]

因为 enum2 和 enum4 将相同的元素传递到 block 中，我们看到这只是做同一件事的两种方式。

这是第三个等效链:

[1,2,3].map.with_index { |i,j| i*j }

我们有:

enum3 = [1,2,3].map
  #=> #<Enumerator: [1, 2, 3]:map>
enum3.to_a
  #=> [1, 2, 3]
enum5 = enum3.with_index
  #=> #<Enumerator: #<Enumerator: [1, 2, 3]:map>:with_index>
enum5.to_a
  #=> [[1, 0], [2, 1], [3, 2]]
enum5.each { |i,j| i*j }
  #=> [0, 2, 6]

为了更进一步，假设我们有:

[1,2,3].select.with_index.with_object({}) { |(i,j),h| ... }

我们有:

enum6 = [1,2,3].select
  #=> #<Enumerator: [1, 2, 3]:select>
enum6.to_a
  #=> [1, 2, 3]
enum7 = enum6.with_index
  #=> #<Enumerator: #<Enumerator: [1, 2, 3]:select>:with_index>
enum7.to_a
  #=> [[1, 0], [2, 1], [3, 2]]
enum8 = enum7.with_object({})
  #=> #<Enumerator: #<Enumerator: #<Enumerator: [1, 2, 3]:
  #     select>:with_index>:with_object({})>
enum8.to_a
  #=> [[[1, 0], {}], [[2, 1], {}], [[3, 2], {}]]

传入 block 的第一个元素 enum8 是数组:

(i,j),h = [[1, 0], {}]

然后应用消歧来为 block 变量赋值:

i => 1
j => 0
h => {}

请注意，enum8 显示在 enum8.to_a 的三个元素中的每一个都传递了一个空散列，但这当然只是因为 Ruby 不知道传入第一个元素后的散列看起来像。