Enumerable モジュール

　　繰り返しを行なうクラスのためのモジュールです．このモジュールのメソッドは全て each を用いて定義されていますので，インクルードするクラスには，each が定義されていなければなりません．

［メソッド］ all?　すべての要素が真である場合に true any?　いずれかの要素が真である場合に true collect　ブロックを評価した結果を全て含む配列 map　ブロックを評価した結果を全て含む配列 find　ブロックを評価した値が真になった最初の要素 detect　ブロックを評価した値が真になった最初の要素 find_all　ブロックを評価した値が真であった要素を全て含む配列 select　ブロックを評価した値が真であった要素を全て含む配列 grep　pattern === item が成立する要素を全て含んだ配列 inject　初期値と繰り返し max　最大の要素 max_by　最大の要素 min　最小の要素 min_by　最小の要素 partition　真偽による要素の分類 reject　偽である要素を集めた配列 sort　ソート sort_by　ソート to_a　全ての要素を含む配列 entries　全ての要素を含む配列 zip　配列の各要素からなる配列

［メソッド］

all?
all? { |item| ･･･ }

　　すべての要素が真である場合に true を返します．ブロックを伴う場合は，各要素に対してブロックを評価します．
```
p [1, 2, 3].all? { |v| v > 0 }   # => true		
```
any?
any? { |item| ･･･ }

　　いずれかの要素が真である場合に true を返します．ブロックを伴う場合は，各要素に対してブロックを評価します．
```
p [-1, 2, -3].any? { |v| v > 0 }   # => true		
```
collect { |item| ･･･ }
map { |item| ･･･ }

　　各要素に対して，ブロックを評価した結果を全て含む配列を返します．ブロックを省略した場合，

obj.collect { |item| item }

を行います．これは to_a と同じです．
```
p [-1, 2, -3].collect { |v| v > 0 }   # => [false, true, false]
p [-1, 2, -3].collect   # => [-1, 2, -3]		
```
find ( [ ifnone ] ) { |item| ･･･ }
detect ( [ ifnone ] ) { |item| ･･･ }

　　要素に対して，ブロックを評価した値が真になった最初の要素を返します．真になる要素がひとつも見つからなかったときは，ifnone （もし，指定されていれば）を評価した後，nil を返します．なお，ifnone には，call メソッドを持つオブジェクトを指定します．例えば，下のプログラムを実行すると，その下に示すような結果が得られます．
```
class Test
	def message
		p "Not Found"
	end
end

obj = Test.new
no  = obj.method("message")
p [-10, 20, -30].find(no) { |v| v > 0 }
p [-10, -20, -30].find(no) { |v| v > 0 }
		
```
（出力）
```
20
"Not Found"
nil		
```
find_all { |item| ･･･ }
select { |item| ･･･ }

　　各要素に対して，ブロックを評価した値が真であった要素を全て含む配列を返します．真になる要素がひとつもなかった場合は，空の配列を返します．
```
p [-10, 20, -30].find_all { |v| v < 0 }   # => [-10, -30]		
```
grep ( pattern )
grep ( pattern ) { |item| ･･･ }

　　pattern === item が成立する要素を全て含んだ配列を返します．ブロックとともに呼び出された時には，条件の成立した要素に対してそれぞれブロックを評価し，その結果の配列を返します．マッチする要素がひとつもなかった場合は，空の配列を返します．
```
p ["abc", "efg", "xab"].grep(/a./)   # => ["abc", "xab"]
p [3, 9, 15].grep(1..10)   # => [3, 9]		
```
inject ( [ init ] ) { |result, item| ･･･ }

　　最初に，初期値 init と self の最初の要素を引数としてブロックを実行します．2 回目以降のループでは，前のブロックの実行結果と self の次の要素を引数に，順次ブロックを実行し，最後のブロックの実行結果を返します．要素が空の場合は，init を返します．

　　初期値 init を省略した場合は，最初に先頭の要素と 2 番目の要素をブロックに渡します．この場合，要素が 1 つしかなければ，ブロックを実行せずに，最初の要素を返します．
```
p [1,2,3,4,5].inject(0) { |result, item| result + item }   # => 15		
```
max
max { |a, b| ･･･ }
max_by { |item| ･･･ }

　　最大の要素を返します．全要素が互いに <=> メソッドで比較できることを仮定しています．ブロックが与えられると，ブロックの評価結果を <=> メソッドで比較して，最大の要素を返します．ブロックの値に対しては，a > b のとき正，a == b のとき 0，a < b のとき負の整数を期待しています．

　　max においては，比較演算毎にブロックの評価を行いますが，max_by では，すべての要素に対してブロックの評価を行った後，比較を行います．従って，ブロックの評価回数が要素の数だけになります．sort と sort_by も参照して下さい．
```
p [5, 4, 3, 2, 1].max   # => 5
p [5, 4, 3, 2, 1].max { |a, b| -a <=> -b }   # => 1		
```
min
min { |a, b| ･･･ }
min_by { |item| ･･･ }

　　最小の要素を返します．全要素が互いに <=> メソッドで比較できることを仮定しています．ブロックが与えられると，ブロックの評価結果を <=> メソッドで比較して，最小の要素を返します．ブロックの値に対しては，a > b のとき正，a == b のとき 0，a < b のとき負の整数を期待しています．

　　min においては，比較演算毎にブロックの評価を行いますが，min_by では，すべての要素に対してブロックの評価を行った後，比較を行います．従って，ブロックの評価回数が要素の数だけになります．sort と sort_by も参照して下さい．
```
p [5, 4, 3, 2, 1].min   # => 1
>p [5, 4, 3, 2, 1].min { |a, b| -a <=> -b }   # => 5		
```
partition { |item| ･･･ }

　　各要素に対して，ブロックを評価した値が真であった要素からなる配列と，偽であった要素からなる配列からなる配列を返します．
```
p [1, 2, 3, 4, 5].partition { |a| a % 2 == 0 }   # => [[2, 4], [1, 3, 5]]		
```
reject { |item| ･･･ }

　　各要素に対してブロックを評価し，その値が偽であった要素を集めた新しい配列を返します．
```
p [1, 2, 3, 4, 5].reject { |a| a % 2 == 0 }   # => [1, 3, 5]		
```
sort
sort { |a, b| ･･･ }
sort_by { |item| ･･･ }

　　全ての要素を昇順にソートした配列を生成して返します．ブロックなしのときは，<=> メソッドを要素に対して呼び，その結果をもとにソートします．

　　<=> 以外でソートしたい場合は，ブロックを指定します．この場合，ブロックの評価結果を元にソートします．ブロックの値に対しては，a > b のとき正，a == b のとき 0，a < b のとき負の整数を期待しています．

　　sort_by も sort と基本的に同じですが，sort においては，比較演算毎にブロックの評価を行いますが，sort_by においては，すべての要素に対してブロックの評価を行った後，比較演算を行います．そのため，ブロックの評価に時間がかかるような場合は，sort_by の処理の方が早くなります．例えば，下に示すプログラムにおいて，count メソッドが呼ばれた回数 $n を比較してみて下さい．
```
class Integer
	def count
		$n += 1
		return self
	end
end

p [2, 1, 5, 3, 4].sort
p [2, 1, 5, 3, 4].sort { |a, b| a <=> b }
p [2, 1, 5, 3, 4].sort { |a, b| -a <=> -b }
p [2, 1, 5, 3, 4].sort { |a, b| (a > b) ? 1 : -1 }
p [2, 1, 5, 3, 4].sort { |a, b| (a < b) ? 1 : -1 }

$n = 0
p [5, 4, 3, 2, 1].sort { |a, b| a.count() <=> b.count() }
printf "   $n = %d\n", $n

$n = 0
p [5, 4, 3, 2, 1].sort_by { |a| a.count() }
printf "   $n = %d\n", $n
		
```
（出力）
```
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]
[1, 2, 3, 4, 5]
   $n = 12
[1, 2, 3, 4, 5]
   $n = 5		
```
to_a
entries

　　全ての要素を含む配列を返します．
```
p (1..5).to_a   # => [1, 2, 3, 4, 5]		
```
zip ( [ ary1 [ , ary2 [ , ･･･ ] ] ])
zip ( [ ary1 [ , ary2 [ , ･･･ ] ] ]) { |v1, v2, ･･･ | ･･･ }

　　オブジェクトと引数に渡した配列の各要素からなる配列（ 1 番目の要素からなる配列，2 番目の要素からなる配列，・・・）の配列を生成して返します．生成される配列の要素数は，オブジェクトの要素数です．ブロック付きで呼び出された場合は，生成された各配列を要素に渡してブロックを実行します．この場合，zip は，常に nil を返します．
```
p [1, 2].zip( [4, 5, 6], [7, 8, 9] )   # => [[1, 4, 7], [2, 5, 8]]
p (1..3).zip( [4, 5], [7, 8, 9] )   # => [[1, 4, 7], [2, 5, 8], [3, nil, 9]]		
```

情報学部

菅沼ホーム

索引