Enumerableなメソッド一覧

versionはRuby2.1。

Enumerableモジュールはeachイテレータを土台とする、便利なメソッドを定義している。
Array,HashはEnumerableモジュールをincludeされており、使用できる。

参考にhttp://ruby-doc.org/core-2.1.0/Enumerable.html

##each_with_object 
なんらかのオブジェクトを渡してeachしたい時に、、、

```rb
["一匹", "二匹", "三匹"].each_with_object("羊") do |item, obj|
  print "#{obj}が#{item}\n"
end
=> 羊が一匹
   羊が二匹
   羊が三匹

(1..5).each_with_object([]){|a,b| b << a*2}
=> [2, 4, 6, 8, 10]

```

##each_with_index
eachされたobjectに番号をつけたい時に、、、、、

```rb
["Bird", "Dog", "Cat"].each_with_index{|a,b| puts "#{b + 1}: #{a}"}

 1: Bird
 2: Dog
 3: Cat
=> ["Bird", "Dog", "Cat"]

```

##each_cons
ある要素(重複)を順番に配列に入れて指定された引数以内に収める

```rb

(1..10).each_cons(2) { |a| p a }

=>[1, 2]
  [2, 3]
  [3, 4]
  [4, 5]
  [5, 6]
  [6, 7]
  [7, 8]
  [8, 9]
  [9, 10]

require 'prime' # (双子素数を探す)
print Prime.each(100).each_cons(2).select{|a,b| b - a == 2}

=>
[[3, 5], [5, 7], [11, 13], [17, 19], [29, 31], [41, 43], [59, 61], [71, 73]]
```

##each_slice
ある要素(重複しない)を順番に配列に入れて指定された引数以内に収める

```
rb(1..10).each_slice(3) { |a| p a }
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
[10]
```

##map または collect

```rb
(1..5).map { |i| i*i } または
(1..5).collect{ |i| i*i }

=> [1, 4, 9, 16]
```

ある配列から要素を検出したい時に、、、

```rb
(1..10).find { |i|  i % 3 == 0 }
=> 3
(1..10).detect { |i|  i % 3 == 0 }
=> 3
```

##find_all または select
ある配列の要素に合致するものをすべて検出したい時に、、、

```rb
(1..10).find_all { |i|  i % 3 == 0 } 
=> [3, 6, 9]

[1,2,3,4,5].select { |num|  num.even?  } 
=> [2, 4]

```

##reject
ある配列の要素に合致しないものをすべて検出したい時に、、、

```rb
[1,2,3,4,5].reject { |num|  num.even?  }
=> [1, 3, 5]
```

##inject または reduce
ある要素を順番に足し算、引き算、かけ算したい

```rb
(5..10).inject(:+)
(5..10)inject {|sum, n| sum + n }
 または
(5..10).reduce(:+)
   

=> 45
```

##all?
ブロックの返り値がすべて真だったらならTrueをかえす。

```rb

[1,3,5,7].all? { |i| i.odd?  }
=> true
%w[tokyo osaka nagoya].all?{ |word| word.length >= 5}
=> true
```

##any?
ブロックの返り値が少なくとも１つ真だったらならTrueをかえす。

```rb

[2,3,4,6].any? { |i| i.odd?  }
=> true
%w[tokyo osaka nagoya].any?{ |word| word.length > 5}
=> true

```

##group_by
要素をグループ分けする

```rb
print ["fox", "lion", "monkey", "dog", "bear"].group_by{|arr| arr[0]}

=> {"f"=>["fox"], "l"=>["lion"], "m"=>["monkey"], "d"=>["dog"], "b"=>["bear"]}
```

##grep
各要素に対して引数に書いた条件に一致した場合に配列に要素をいれてArrayで返す。

```rb

print (1..10).grep(2..6)
=> [2, 3, 4, 5, 6]

print ["capybara", "rspec"].grep(/\A[A-Za-z]+\Z/)
=> ["capybara", "rspec"]

```
##max あるいは max_by
ある配列の中で文字数の大きい要素や一番大きい数字を取り出す

```rb
[44,10,3,99,1].max
=> 99

%w(amazon movie google).max_by{|a| a.length}
=> "amazon"
```

##min あるいは min_by
ある配列の中で文字数の小さい要素や一番小さい数字を取り出す

```rb
[44,10,3,99,1].min
=> 1

%w(amazon movie google).min_by{|a| a.length}
=> "movie"
```

##minmax
ある配列の中で一番大きい要素と一番小さい要素を同時に取り出す

```rb
[44,10,3,99,1].minmax
=> [1, 99]

%w(aaa aa aaaa aaaaa a).minmax_by{|a| a.length}
=> ["a", "aaaaa"]

```

##reverse_each
ある要素を反対からeachしていく

```rb
(1..3).reverse_each{|a| p a}
=> 3
   2
   1
```

##sort あるいは sort_by
ある要素をアルファベット順に並べる

```rb
%w[kiwi grapefruit watermelon apple].sort
=> ["apple", "grapefruit", "kiwi", "watermelon"]

 (1..10).sort{|a,b| b <=> a}
=> [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

%w[kiwi grapefruit watermelon apple].sort_by { |word| word.length}
=> ["kiwi", "apple", "grapefruit", "watermelon"]
```

##first あるいは take
ある配列の要素を先頭から取り出す

```rb

["kiwi", "apple", "grapefruit", "watermelon"].first(2)
=> ["kiwi", "apple"]

["kiwi", "apple", "grapefruit", "watermelon"].take(2)
=> ["kiwi", "apple"]

```

##take_while
ある配列の要素を先頭から取り出す(ブロックを取る場合)、一致する要素を先頭から返していく、先頭から要素が条件に一致しない場合はnilを返す

```rb
 ["kiwi", "apple", "grapefruit", "watermelon"].take_while{|a| a.length < 5}
=> ["kiwi"]

 ["kiwi", "apple", "grapefruit", "watermelon"].take_while{|a| a.length < 1}
=> []

```

##drop
先頭のn個の要素を除く配列で返す(firstの反対)

```rb
["kiwi", "apple", "grapefruit", "watermelon"].drop(2)
=> ["grapefruit", "watermelon"]
```

##partition
ある要素を二つの配列に分けて、配列の配列でネストした状態で返す。
条件に合致したもの、そうでないものとに分ける

```rb

 (1..10).partition{|a| a.even? }
=> [[2, 4, 6, 8, 10], [1, 3, 5, 7, 9]]

```

##zip
配列の要素を引数の配列の要素と組み合わせて配列の配列でネストした形で返す

```rb
a = [2, 4, 6]
p [1, 3, 5].zip(a)

=> [[1, 2], [3, 4], [5, 6]]
```
##count
要素の数を返す

```rb

[1,2,3,4,5,6].count
=> 6

(1..10).count{|a| a % 2 == 0}
=> 5

```

##cycle
配列の要素の数だけ実行し引数の数だけ繰り返し実行する。
引数が指定されてない場合は無限ループする。

```rb

arr = [1,2,3,4,5,6,7,8,9]
arr.cycle(2) {|item| print "#{item} " }

=> 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 

```

##flat_map あるいは collect_concat
配列の配列でネストされた要素を１つの配列に連結する

```rb
print [[1,2],[3,4]].flat_map{|i| i}
print [[1,2],[3,4]].collect_concat{|i| i}

=> [1, 2, 3, 4]

```