ruby 可枚举模块Enumerable

Enumerable模块提供了遍历，搜索，比较，排序等方法。如果我们自定义的类需要实现这些方法，必须实现一个each方法。如果需要使用max,min,sort等方法，因为这些方法是集合的元素之间的排序，所以该类还必须使用<=>方法；

Array，Hash，Range，IO都Mix-in了该模块

一. 遍历，搜索方法

• all? {|item| ... }
  当所有元素都为真时,返回true. 若某元素为假时, 立即返回false

  p [1,2,3].all? {|v| v > 0}   # => true
  p [1,2,3].all? {|v| v > 1}   # => false

• any? {|item| ... }
  当所有元素都为假时,返回false. 一旦某元素为真时, 立即返回true.

  p [1,2,3].any? {|v| v > 3}   # => false
  p [1,2,3].any? {|v| v > 1}   # => true

• collect {|item| ... }
  map {|item| ... }
  依此为各元素执行块的内容,并将结果存入数组,最后返回该数组

  p [1,2,3].map {|v| v + 1}   # => [2, 3, 4]

• each_with_index {|item,index| ... }
  使用元素及其索引进行循环操作的迭代器

  ['a', 'b', 'c', 'd'].each_with_index{|obj, i| puts "#{obj} - #{i}"}
  #=>

  a - 0
  b - 1
  c - 2
  d - 3

• find([ifnone]) {|item| ... }
  在使用元素进行块的计算时, 返回计算值首次为真的那个元素. 若块的计算值始终都不为真时, 则计算ifnone部分(若有的话),并返回nil.

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

• find_all {|item| ... }
  select {|item| ... }
  在使用元素进行块的计算时,若计算值为真则把该元素存入数组,最后返回该数组. 若块的计算值始终都不为真时,则返回空数组

  p [1, 2, 3, 4, 5].select{|i| i>3} #=> [4, 5]

• member?(val)
  include?(val)
  若val==某元素时,返回true

  p (1..2).include?(2) #=> true

• inject([init]) {|result, item| ... }
  开始时,把初始值init和self的首元素当做块参数来计算块的内容. 从第2次循环开始, 将把上次的块的计算结果和self的下个元素当做块参数来计算块. 这样一直循环到最后的元素, 返回最后的块的计算结果.
  若没有元素,则返回init.
  若省略了初始值init的话, 开始时会把第1和第2个元素传递给块. 此时, 若只有1个元素时,将直接返回首元素,而不会执行块. 若没有元素,则返回nil

  p [1, 2, 3, 4, 5].inject{|sum, i| sum + i}  #=> 15i
  p [3, 4, 5].inject(2){|product, i| product * i} #=> 120

• reduce(initial, sym)
  reduce(sym)
  reduce(initial) { |memo, obj| block }
  reduce { |memo, obj| block }
  reduce作用和inject优点类似，但是它比inject还要简洁

  # Sum some numbers
  (5..10).reduce(:+)                             #=> 45
  # Same using a block and inject
  (5..10).inject { |sum, n| sum + n }            #=> 45
  # Multiply some numbers
  (5..10).reduce(1, :*)                          #=> 151200
  # Same using a block
  (5..10).inject(1) { |product, n| product * n } #=> 151200
  # find the longest word
  longest = %w{ cat sheep bear }.inject do |memo, word|
     memo.length > word.length ? memo : word
  end
  longest                                        #=> "sheep"

• partition {|item| ... }
  若对某元素执行块的结果为真, 则把该元素归入第一个数组;若为假则将其归入第二个数组,最后生成并返回一个包含这两个数组的新数组.

  p [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0].partition { |i| i % 3 == 0 }
  #=> [[9, 6, 3, 0], [10, 8, 7, 5, 4, 2, 1]]

• group_by { |obj| block } → a_hash 
  group_by → an_enumerator
  根据块的结果对集合进行分组。返回一个散列，其中键是来自块的评估结果，值是集合中与键对应的元素数组
  如果没有给定一个区块，则返回一个枚举器enumerator

  (1..6).group_by { |i| i%3 }   #=> {0=>[3, 6], 1=>[1, 4], 2=>[2, 5]}

二. 比较，排序方法

• max {|a, b| ... }

  以块的计算结果来判断各个元素的大小, 并返回最大的元素.

  通常要求该块返回下列各整数值: 当a>b时返回正整数,a==b时返回0,而a<b时返回负整数. 若该块返回了一个非整数值时, 会引发TypeError异常

  arr = ['string', 'array', 'enumberable']
  p arr.max #=> "string"
  p arr.max{|a, b| a.length <=> b.length} #=> "enumberable"

• min {|a, b| ... }
  以块的计算结果来判断各个元素的大小, 并返回最小的元素.
  通常要求该块返回下列各整数值: 当a>b时返回正整数,a==b时返回0,而a<b时返回负整数. 若该块返回了一个非整数值时, 会引发TypeError异常.
• sort {|a, b| ... }
  对所有元素进行升序排列后返回这个新的数组.
  若不带块时, 将以<=>方法的比较结果为基础进行排序.
  如果想借用<=>之外的方法进行排序时,可以指定一个块. 此时将以块的计算结果为基础进行排序. 通常要求该块返回下列各值: 当a>b时返回正整数,a==b时返回0,而a<b时返回负整数. 若该块返回了一个非整数值时, 会引发TypeError异常.
  Enumerable#sort 所进行的是不稳定的排序(unstable sort)。
  注: 排序后,若相等的元素的位置并未改变的话,这种排序就是"稳定的排序(stable sort)".

  p [1, 3, 4, 2].sort #=> [1, 2, 3, 4]

• sort_by {|item| ... }
  以<=>方法来比较块的计算值, 并对self进行升序排列,最后生成并返回新生成的数组

  p ['string', 'array', 'enumberable'].sort_by{|world| world.length}
  #=> ["array", "string", "enumberable"]