Enumerable模块提供了遍历，搜索，比较，排序等方法。如果我们自定义的类需要实现这些方法，必须实现一个each方法。如果需要使用max,min,sort等方法，因为这些方法是集合的元素之间的排序，所以该类还必须使用<=>方法；
Array，Hash，Range，IO都Mix-in了该模块
一. 遍历，搜索方法
- all? {|item| ... }
当所有元素都为真时,返回true. 若某元素为假时, 立即返回falsep [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| ... }
在使用元素进行块的计算时, 返回计算值首次为真的那个元素. 若块的计算值始终都不为真时, 则计算部分(若有的话),并返回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)
若==某元素时,返回truep (1..2).include?(2) #=> true
- inject([init]) {|result, item| ... }
开始时,把初始值init和self的首元素当做块参数来计算块的内容. 从第2次循环开始, 将把上次的块的计算结果和self的下个元素当做块参数来计算块. 这样一直循环到最后的元素, 返回最后的块的计算结果.
若没有元素,则返回init.
若省略了初始值init的话, 开始时会把第1和第2个元素传递给块. 此时, 若只有1个元素时,将直接返回首元素,而不会执行块. 若没有元素,则返回nilp [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"]