ruby - Ruby中的高阶迭代器？

Question

我在阅读有关.each迭代器的Ruby问题，有人说如果更高阶的迭代器更适合该任务，则使用.each可能会产生代码味道。 Ruby中的高阶迭代器是什么？

编辑:我提到的StackOverflow答案的作者JörgW Mittag提到他是要编写更高级别的迭代器，但他还解释了下面的内容。

Answer 1

哎呀。我的意思是更高级别的迭代器，而不是更高阶的迭代器。当然，每个迭代器都是高阶的。

基本上，迭代是一个非常低级的概念。编程的目的是与团队中的其他利益相关者交流意图。 “初始化一个空数组，然后遍历另一个数组，并将该数组的当前元素添加到第一个数组中(如果该数组可以被两个整除而没有余数的话)，这并不是在传达意图。 “选择所有偶数”是。

通常，您几乎永远不会只是为了迭代而对集合进行迭代。你要么想要

以某种方式转换每个元素(通常称为map，在Ruby和Smalltalk中为collect，在.NET和SQL中为Select)，

将整个集合减少到某个单一值，例如计算足球得分列表的总和，平均值或标准偏差(在类别理论中，这称为超文本变形；在函数式编程中，它是fold或reduce；在Smalltalk中，它是inject:into:；在Ruby中是inject；在.NET Aggregate中) ，

过滤掉满足特定条件的所有元素(大多数功能语言中的filter，Smalltalk和Ruby中的select，Ruby中的find_all，.NET和SQL中的Where)，

过滤掉所有不满足条件的元素(Smalltalk和Ruby中的reject)

查找满足条件的第一个元素(Ruby中的find)

计算满足条件的元素(Ruby中的count)

检查是否所有元素(all?)，至少一个元素(any?)或没有元素(none?)满足条件

根据一些区分符(Ruby，.NET和SQL中的group_by)将元素分组到存储桶中

根据某个谓词(partition)将该集合分为两个集合

对集合(sort，sort_by)进行排序

将多个集合合并为一个(zip)

等，依此类推……

您的目标几乎永远不会只是遍历一个集合。

特别是 reduce。 inject aka。 fold aka。 inject:into: aka。 Aggregate aka。变态是你的 friend 。它之所以听起来如此花哨的数学名称是有原因的:它非常强大。实际上，我上面提到的大多数内容都可以根据 reduce来实现。

基本上， reduce的作用是使用某些函数将整个集合“缩减”为单个值。您有某种累加器值，然后取累加器值和第一个元素并将其输入到函数中。然后，该函数的结果将成为新的累加器，您可以将其与第二个元素配对并馈入该函数，依此类推。

最明显的例子是对数字列表求和:

[4, 8, 15, 16, 23, 42].reduce(0) {|acc, elem|
  acc + elem
}

因此，累加器以 0开头，然后将第一个元素 4传递到 +函数中。结果是 4，它成为新的累加器。现在我们传入下一个元素 8，结果是 12。这一直持续到最后一个元素，结果是他们一直死了。不，等等，结果是 108。

Ruby实际上允许我们采取一些捷径:如果元素类型与累加器类型相同，则可以省去累加器，Ruby会简单地将第一个元素作为累加器的第一个值:

[4, 8, 15, 16, 23, 42].reduce {|acc, elem|
  acc + elem
}

另外，我们可以在这里使用 Symbol#to_proc:

[4, 8, 15, 16, 23, 42].reduce(&:+)

实际上，如果您将 reduce传递给 Symbol参数，它将被视为用于归约操作的函数的名称:

[4, 8, 15, 16, 23, 42].reduce(:+)

但是，求和并不是 reduce可以完成的全部工作。实际上，我发现此示例有些危险。我向所有人展示的这些内容立即理解为:“啊，这就是 reduce的意思”，但是不幸的是，有些人还认为 reduce就是所有数字的总和，而事实并非如此。实际上， reduce是一种通用的迭代方法，我的意思是 reduce可以执行 each可以执行的任何操作。特别是，您可以在累加器中存储任意状态。

例如，我在上面写道， reduce将集合缩减为单个值。但是，当然，“单一值(value)”可能是任意复杂的。例如，它本身可以是一个集合。或字符串:

class Array
  def mystery_method(foo)
    drop(1).reduce("#{first}") {|s, el| s << foo.to_str << el.to_s }
  end
end

这是一个示例，您可以使用累加器玩多远的技巧。如果您尝试一下，您当然会认出它为 Array#join:

class Array
  def join(sep=$,)
    drop(1).reduce("#{first}") {|s, el| s << sep.to_str << el.to_s }
  end
end

请注意，在此“循环”中的任何地方都不必跟踪我是在最后一个元素还是倒数第二个元素。代码中也没有任何条件。这里没有潜在的篱笆错误。如果考虑如何使用 each实现此功能，则必须以某种方式跟踪索引并检查是否在最后一个元素中，然后在其中添加一个 if，以防止在末尾发出分隔符。

由于我在上面写道，所有迭代都可以使用 reduce完成，所以我也可能会证明这一点。这是Ruby的 Enumerable方法，是根据 reduce而不是通常的 each实现的。 (请注意，我才刚刚开始，才刚到达g。)

module Enumerable
  def all?
    reduce(true) {|res, el| res && yield(el) }
  end

  def any?
    reduce(false) {|res, el| res || yield(el) }
  end

  alias_method :map, def collect
    reduce([]) {|res, el| res << yield(el) }
  end

  def count
    reduce(0) {|res, el| res + 1 if yield el }
  end

  alias_method :find, def detect
    reduce(nil) {|res, el| if yield el then el end unless res }
  end

  def drop(n=1)
    reduce([]) {|res, el| res.tap {|res| res << el unless n -= 1 >= 0 }}
  end

  def drop_while
    reduce([]) {|res, el| res.tap {|res| res << el unless yield el }}
  end

  def each
    reduce(nil) {|_, el| yield el }
  end

  def each_with_index
    tap { reduce(-1) {|i, el| (i+1).tap {|i| yield el, i }}}
  end

  alias_method :select, def find_all
    reduce([]) {|res, el| res.tap {|res| res << el if yield el }}
  end

  def grep(pattern)
    reduce([]) {|res, el| res.tap {|res| res << yield(el) if pattern === el }}
  end

  def group_by
    reduce(Hash.new {|hsh, key| hsh[key] = [] }) {|res, el| res.tap {|res|
        res[yield el] = el
    }}
  end

  def include?(obj)
    reduce(false) {|res, el| break true if res || el == obj }
  end

  def reject
    reduce([]) {|res, el| res.tap {|res| res << el unless yield el }}
  end
end

[注意:出于这篇文章的目的，我做了一些简化。例如，根据标准的Ruby Enumerable协议(protocol)， each应该返回 self，因此您必须在其中打额外的一行。其他方法的行为略有不同，具体取决于您传入的种类和参数数量等等。我将这些内容排除在外是因为它们分散了我要提出的观点。]