在 Ruby 中使用 to_enum 创建可枚举对象有什么好处？

Question

为什么要使用 to_enum 方法而不是直接使用对象来创建对 Ruby 中对象的代理引用？我想不出任何实际用途，试图理解这个概念和概念。有人可能会使用它，但我见过的所有例子似乎都很微不足道。

例如，为什么使用：

"hello".enum_for(:each_char).map {|c| c.succ }

而不是

"hello".each_char.map {|c| c.succ }

我知道这是一个非常简单的例子，有人有任何现实世界的例子吗？

Answer 1

如果没有提供块，大多数接受块的内置方法都会返回一个枚举器（例如示例中的 String#each_char ）。对于这些，没有理由使用 to_enum；两者将产生相同的效果。

不过，有一些方法不返回枚举器。在这种情况下，您可能需要使用 to_enum。

# How many elements are equal to their position in the array?
[4, 1, 2, 0].to_enum(:count).each_with_index{|elem, index| elem == index} #=> 2

另一个例子，Array#product、#uniq 和 #uniq! 不用于接受块。在 1.9.2 中，这一点已更改，但为了保持兼容性，没有块的表单无法返回 Enumerator。人们仍然可以“手动”使用 to_enum 来获取枚举器：

require 'backports/1.9.2/array/product' # or use Ruby 1.9.2+
# to avoid generating a huge intermediary array:
e = many_moves.to_enum(:product, many_responses)
e.any? do |move, response|
  # some criteria
end 

to_enum 的主要用途是当您实现自己的迭代方法时。您通常会将以下内容作为第一行：

def my_each
  return to_enum :my_each unless block_given?
  # ...
end

Answer 2

我认为这与内部和外部迭代器有关。当您返回这样的枚举器时：

p = "hello".enum_for(:each_char)

p 是外部枚举器。外部迭代器的优点之一是：

外部迭代器比内部迭代器更灵活。例如，使用外部迭代器比较两个集合的相等性很容易，但使用内部迭代器实际上是不可能的......但另一方面，内部迭代器更容易使用，因为它们为您定义了迭代逻辑。 [摘自《Ruby 编程语言》一书，第 1 章。 5.3]

所以，使用外部迭代器你可以这样做，例如：

p = "hello".enum_for(:each_char)
loop do
    puts p.next
end

Answer 3

假设我们想要获取一个键数组和一个值数组并将它们缝合在哈希中：

With #to_enum

def hashify(k, v)
  keys = k.to_enum(:each)
  values = v.to_enum(:each)
  hash = []
  loop do
    hash[keys.next] = values.next
    # No need to check for bounds,
    # as #next will raise a StopIteration which breaks from the loop
  end
  hash
end

Without #to_enum:

def hashify(k, v)
  hash = []
  keys.each_with_index do |key, index|
    break if index == values.length
    hash[key] = values[index]
  end
  hash
end

阅读起来要容易得多第一种方法，你觉得呢？不是很容易，但想象一下如果我们以某种方式操作 3 个数组中的项目会怎样？ 5？ 10？

Answer 4

这并不完全是您问题的答案，但希望它是相关的。

在第二个示例中，您调用 each_char 而不传递块。当不使用块调用时，each_char 返回一个Enumerator，因此您的示例实际上只是执行同一操作的两种方法。 （即两者都会导致创建可枚举对象。）

irb(main):016:0> e1 = "hello".enum_for(:each_char)
=> #<Enumerator:0xe15ab8>
irb(main):017:0> e2 = "hello".each_char
=> #<Enumerator:0xe0bd38>
irb(main):018:0> e1.map { |c| c.succ }
=> ["i", "f", "m", "m", "p"]
irb(main):019:0> e2.map { |c| c.succ }
=> ["i", "f", "m", "m", "p"]

Answer 5

它非常适合大型或无限的生成器对象。
例如，下面将为您提供整个斐波那契数列的枚举器，从 0 到无穷大。

def fib_sequence
  return to_enum(:fib_sequence) unless block_given?
  yield 0
  yield 1
  x,y, = 0, 1
  loop { x,y = y,x+y; yield(y) }
end

to_enum 有效地允许您使用常规的 yields 编写此代码，而不必弄乱 Fiber。

然后，您可以根据需要对其进行切片，这将非常节省内存，因为内存中不会存储任何数组：

module Slice
    def slice(range)
        return to_enum(:slice, range) unless block_given?
        start, finish = range.first, range.max + 1
        copy = self.dup
        start.times { copy.next }
        (finish-start).times { yield copy.next }
    end
end
class Enumerator
    include Slice
end

fib_sequence.slice(0..10).to_a
#=> [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
fib_sequence.slice(10..20).to_a                                                                                                                           
#=> [55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]