Enumerable和Comparable是Ruby提供的非常重要的模块。这一篇文章主要介绍Enumerable的一些方法。
Enumerable模块提供了遍历，搜索，排序等方法。如果我们自定义的类需要实现这些方法，必须实现一个each方法。如果需要使用max,min,sort等方法，因为这些方法是集合的元素之间的排序，所以该类还必须使用<=>方法。
实例方法
1.all?[{|obj| block}] -> true of false
%w[ant bear cat].all? { |word| word.length >= 3 } #=> true
%w[ant bear cat].all? { |word| word.length >= 4 } #=> false
[nil, true, 99].all? #=> false
2.any?[{|obj| block}] -> true of false
%w[ant bear cat].any? { |word| word.length >= 3 } #=> true
%w[ant bear cat].any? { |word| word.length >= 4 } #=> true
[nil, true, 99].any? #=> true
3.chunk{|elt| ...} -> an_enumerator OR chunk(initial_state){|elt,state|...} -> an_enumerator
从文档可以看出：该方法将结果返回一个Enumerator实例。这种情况在Enumerable模块中经常可以看到，那么我们就可以完整的使用Enumerator类的方法，由于Enumerator类又继承了Enumerable类的所有方法，所以可以看到对于返回的结果进行了扩充。
下面列出Enumerator的实例方法，在下一篇文章在详细的介绍Enumerator。#each,#each_with_index,#each_with_object,#feed,#inspect,#next,#next_values,#peek,#peek_values,#rewind,#size,#with_index,#with_object
栗子：
[3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5].chunk { |n|
n.even?
}.each { |even, ary|
p [even, ary]
}
#=> [false, [3, 1]]
# [true, [4]]
# [false, [1, 5, 9]]
# [true, [2, 6]]
# [false, [5, 3, 5]]
可以看出来chunk方法返回的Enumerator对象的元素是由（block处理的结果,[元素])组成的
require 'pp'
[1,2,3,4,5,6,7,8].chunk do |n|
n+1
end.each do |n,arr|
pp [n,arr]
end
返回的结果如下：
[2, [1]]
[3, [2]]
[4, [3]]
[5, [4]]
[6, [5]]
[7, [6]]
[8, [7]]
[9, [8]]
此方法非常适合将元素排序，下面的栗子计算了单词的每个开头字母
open('words') do |f|
#首先我们在block中返回words文件中的所有行，没有对其进行任何处理
#输出的结果：是每行的开头字母，以及每行的长度。
f.chunk { |line| line }.each { |ch,line| pp [ch.chr, line[0].length] }
end
4.collect{|obj|block} OR collect -> an_enumerator
(1..4).collect { |i| i*i } #=> [1, 4, 9, 16]
(1..4).collect { "cat" } #=> ["cat", "cat", "cat", "cat"]
5.collect_concat{|obj| block} -> array OR collect_concat -> an_enumerator
[1, 2, 3, 4].flat_map { |e| [e, -e] } #=> [1, -1, 2, -2, 3, -3, 4, -4]
[[1, 2], [3, 4]].flat_map { |e| e + [100] } #=> [1, 2, 100, 3, 4, 100]
别名就是flat_map
6.count -> int OR count(item) -> int OR count{ |obj| block } -> int
返回集合的数量，如果传递了参数，返回集合中和参数相同元素的个数，如果传递了block，返回block中为真的元素个数
ary = [1, 2, 4, 2]
ary.count #=> 4
ary.count(2) #=> 2
ary.count{ |x| x%2==0 } #=> 3
7.cycle(n=nil) {|obj| block} -> nil OR cycle(n=nil) -> an_enumerator
a = ["a", "b", "c"]
a.cycle { |x| puts x } # 打印： a, b, c, a, b, c,...无限多个
a.cycle(2) { |x| puts x } # 打印：a, b, c, a, b, c.
8.detect(ifnone=nil){|obj| block} -> obj or nil OR detect(ifnone=nil) -> an_enumerator
(1..10).detect { |i| i % 5 == 0 and i % 7 == 0 } #=> nil
(1..100).detect { |i| i % 5 == 0 and i % 7 == 0 } #=> 35
当然如果该方法没有返回值时，可以为该方法指定一个默认值：
class Test
def default
'I am default'
end
end
t = Test.new
pp (1..10).detect(t.method(:default)) { |i| i > 10 }
或者
pp (1..10).detect(lambda { "I am default" }) { |i| i > 10 }
9.drop(n) -> array
删除前n项元素，返回剩余元素
a = [1, 2, 3, 4, 5, 0]
a.drop(3) #=> [4, 5, 0]
10.drop_while{|arr| block} -> array OR drop_while -> an_enumerator
a = [1, 2, 3, 4, 5, 0]
a.drop_while { |i| i < 3 } #=> [3, 4, 5, 0]
11.each_cons(n){...} -> nil OR each_cons(n) -> an_enumerator
(1..10).each_cons(3) { |a| p a }
# 结果如下
[1, 2, 3]
[2, 3, 4]
[3, 4, 5]
[4, 5, 6]
[5, 6, 7]
[6, 7, 8]
[7, 8, 9]
[8, 9, 10]
12.ench_entry{|obj| block} -> enum
%w(1 2 3 4).each_entry {|x| p x}
13.each_slice(n){...} -> nil OR each_slice(n) -> an_enumerator
(1..10).each_slice(3) { |a| p a }
# 结果如下
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
[10]
14.each_with_index(*args){|obj,i| block} -> enum OR each_with_index(*args) -> an_enumerator
hash = Hash.new
%w(cat dog wombat).each_with_index { |item, index|
hash[item] = index
}
hash #=> {"cat"=>0, "dog"=>1, "wombat"=>2}
15.each_with_object(obj){|(*args), memo_obj|...} -> obj OR each_with_object(obj) -> an_enumerator
evens = (1..10).each_with_object([]) { |i, a| a << i*2 }
#=> [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
16.entries -> array
(1..7).to_a #=> [1, 2, 3, 4, 5, 6, 7]
{ 'a'=>1, 'b'=>2, 'c'=>3 }.to_a #=> [["a", 1], ["b", 2], ["c", 3]]
17.find同detect
18.find_all{|obj| block} -> array OR find_all -> an_enumerator
(1..10).find_all { |i| i % 3 == 0 } #=> [3, 6, 9]
[1,2,3,4,5].select { |num| num.even? } #=> [2, 4]
19.finde_index(value) -> int or nil OR finde_index{|obj| block} -> int or nil
(1..10).find_index { |i| i % 5 == 0 and i % 7 == 0 } #=> nil
(1..100).find_index { |i| i % 5 == 0 and i % 7 == 0 } #=> 34
(1..100).find_index(50) #=> 49
20.first -> obj or nil OR first(n) -> an_array
%w[foo bar baz].first #=> "foo"
%w[foo bar baz].first(2) #=> ["foo", "bar"]
%w[foo bar baz].first(10) #=> ["foo", "bar", "baz"]
[].first #=> nil
21.grep(pattern) -> array OR grep(pattern) {|obj| block} -> array
(1..100).grep 38..44 #=> [38, 39, 40, 41, 42, 43, 44]
c = IO.constants
c.grep(/SEEK/) #=> [:SEEK_SET, :SEEK_CUR, :SEEK_END]
res = c.grep(/SEEK/) { |v| IO.const_get(v) }
res #=> [0, 1, 2]
22.group_by{|obj| block} -> a_hash OR group_by -> an_enumerator
(1..6).group_by { |i| i%3 } #=> {0=>[3, 6], 1=>[1, 4], 2=>[2, 5]}
23.include?(obj) -> true or false
IO.constants.include? :SEEK_SET #=> true
IO.constants.include? :SEEK_NO_FURTHER #=> false
24.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"
25.none? [{|obj| block}] -> true or false
%w{ant bear cat}.none? { |word| word.length == 5 } #=> true
%w{ant bear cat}.none? { |word| word.length >= 4 } #=> false
[].none? #=> true
[nil].none? #=> true
[nil, false].none? #=> true
26.one? [{|obj| block} -> true or false]
%w{ant bear cat}.one? { |word| word.length == 4 } #=> true
%w{ant bear cat}.one? { |word| word.length > 4 } #=> false
%w{ant bear cat}.one? { |word| word.length < 4 } #=> false
[ nil, true, 99 ].one? #=> false
[ nil, true, false ].one? #=> true
27.partition {|obj| block} -> [true_array, false_array]
分区方法
(1..6).partition { |v| v.even? } #=> [[2, 4, 6], [1, 3, 5]]
