Ruby 1.9.2 リファレンスマニュアル > ライブラリ一覧 > 組み込みライブラリ > Enumerableモジュール

module Enumerable

クラスの継承リスト: Enumerable

Abstract

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

インスタンスメソッド

all? -> bool
all? {|item| ... } -> bool

すべての要素が真である場合に true を返します。 偽である要素があれば、ただちに false を返します。

ブロックを伴う場合は、各要素に対してブロックを評価し、すべての結果 が真である場合に true を返します。ブロックが偽を返した時点で、 ただちに false を返します。

例: 

# すべて正の数か？
p [5,  6, 7].all? {|v| v > 0 }   # => true
p [5, -1, 7].all? {|v| v > 0 }   # => false
any? -> bool
any? {|item| ... } -> bool

すべての要素が偽である場合に false を返します。 真である要素があれば、ただちに true を返します。

ブロックを伴う場合は、各要素に対してブロックを評価し、すべての結果 が偽である場合に false を返します。ブロックが真を返した時点 で、ただちに true を返します。

例: 

p [1, 2, 3].any? {|v| v > 3 }   # => false
p [1, 2, 3].any? {|v| v > 1 }   # => true
collect -> Enumerator
map -> Enumerator
collect {|item| ... } -> [object]
map {|item| ... } -> [object]

各要素に対してブロックを評価した結果を全て含む配列を返します。

例: 

# すべて 3 倍にする
p [1, 2, 3].map {|n| n * 3 }  # => [3, 6, 9]
count -> Integer
count(item) -> Integer
count {|obj| ... } -> Integer

レシーバの要素数を返します。

引数を指定しない場合は、レシーバの要素数を返します。 このとき、レシーバが size メソッドを持っていればそちらを使用します。 レシーバが size メソッドを持っていない場合は、要素数を一つずつカウントします。

引数を一つ指定した場合は、レシーバの要素のうち引数に一致するものの 個数をカウントして返します。

ブロックを指定した場合は、ブロックを評価して真になった要素の個数を カウントして返します。

[PARAM] item:
カウント対象となる値。

例: 

ary = [1, 2, 4, 2]
ary.count             # => 4
ary.count(2)          # => 2
ary.count{|x|x%2==0}  # => 3
cycle -> Enumerator
cycle {|obj| ... } -> object | nil

Enumerable オブジェクトの要素を、繰り返し無限に生成し続けます。

Calls block for each element of enum repeatedly forever. Returns nil if and only if the collection is empty. Enumerable#cycle saves elements in an internal array so changes to enum after the first pass have no effect.

[RETURN]
ブロックを指定しなかった場合は、Enumerable::Enumerator を返します。 レシーバが空の場合は nil を返します。 
a = ["a", "b", "c"]
a.cycle {|x| puts x }  # print, a, b, c, a, b, c,.. forever.
find(ifnone = nil) -> Enumerator
detect(ifnone = nil) -> Enumerator
find(ifnone = nil) {|item| ... } -> object
detect(ifnone = nil) {|item| ... } -> object

要素に対してブロックを評価した値が真になった最初の要素を返します。

真になる要素が見つからず、 ifnone も指定されていないときは nil を返します。 真になる要素が見付からず、ifnone が指定されているときは ifnone を eval または call して実行し、nil を返します。

[PARAM] ifnone:
call メソッドを持つオブジェクト (例えば Proc) を指定します。

例: 

# 最初の 3 の倍数を探す
p [1, 2, 3, 4, 5].find {|i| i % 3 == 0 }   # => 3
p [2, 2, 2, 2, 2].find {|i| i % 3 == 0 }   # => nil

# ifnone の使用例
ifnone = proc { raise ArgumentError, "item not found" }
p [1, 2, 3, 4, 5].find(ifnone) {|i| i % 7 == 0 }
    # ArgumentError: item not found
drop(n) -> Array

Enumerable オブジェクトの先頭の n 要素を捨てて、 残りの要素を配列として返します。

[PARAM] n:
捨てる要素数。 
a = [1, 2, 3, 4, 5, 0]
a.drop(3)             # => [4, 5, 0]
drop_while -> Enumerator
drop_while {|element| ... } -> Array

ブロックを評価して最初に偽となった要素の手前の要素まで捨て、 残りの要素を配列として返します。

ブロックを指定しなかった場合は、Enumerable::Enumerator を返します。 

a = [1, 2, 3, 4, 5, 0]
a.drop_while {|i| i < 3 }   # => [3, 4, 5, 0]
each_cons(n) -> Enumerator
each_cons(n) {|list| ... } -> nil

要素を重複ありで n 要素ずつに区切り、 ブロックに渡して繰り返します。

[PARAM] n:
区切る要素数を示す整数です。

例: 

[1, 2, 3, 4, 5].each_cons(3) {|a| p a }
    # => [1, 2, 3]
    #    [2, 3, 4]
    #    [3, 4, 5]

[SEE_ALSO] Enumerable#each_slice

each_slice(n) -> Enumerator
each_slice(n) {|list| ... } -> nil

n 要素ずつブロックに渡して繰り返します。

要素数が n で割り切れないときは、最後の回だけ要素数が減ります。

[PARAM] n:
区切る要素数を示す整数です。

例: 

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

[SEE_ALSO] Enumerable#each_cons

each_with_index -> Enumerator
each_with_index {|item, index| ... } -> self

要素とそのインデックスをブロックに渡して繰り返します。

self を返します。

例: 

[5, 10, 15].each_with_index do |n, idx|
  p [n, idx]
end
    # => [5, 0]
    #    [10, 1]
    #    [15, 2]
each_with_object(obj) -> Enumerator
each_with_object(obj) {|(*args), memo_obj| ... } -> object

[SEE_ALSO] Enumerator#with_object

to_a -> [object]
entries -> [object]

全ての要素を含む配列を返します。

find_all -> Enumerator
select -> Enumerator
find_all {|item| ... } -> [object]
select {|item| ... } -> [object]

各要素に対してブロックを評価した値が真であった要素を全て含む配列を 返します。真になる要素がひとつもなかった場合は空の配列を返します。

find_index -> Enumerator
find_index {|obj| ... } -> Integer | nil

すべての要素をブロックに渡して評価し、最初に真になった要素の インデックスを返します。

一つも真にならなければ 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
first -> object | nil
first(n) -> Array

Enumerable オブジェクトの最初の要素、もしくは最初の n 要素を返します。

Enumerable オブジェクトが空の場合、引数を指定しない形式では nil を返します。 引数を指定する形式では、空の配列を返します。

[PARAM] n:
取得する要素数。 
h = {:a => 1, :b => 2, :c => 3}
p h.first     #=> [:b, 2]
p h.first(2)  #=> [[:b, 2], [:c, 3]]
p {}.first    #=> nil
p {}.first(2) #=> []
grep(pattern) -> [object]
grep(pattern) {|item| ... } -> [object]

pattern === item が成立する要素を全て含んだ配列を返します。 ブロックとともに呼び出された時には条件の成立した要素に対して それぞれブロックを評価し、その結果の配列を返します。 マッチする要素がひとつもなかった場合は空の配列を返します。

[PARAM] pattern:
「===」メソッドを持つオブジェクトを指定します。

例: 

p ['aa', 'bb', 'cc', 'dd', 'ee'].grep(/[bc]/)  # => ["bb", "cc"]
group_by -> Enumerator
group_by {|obj| ... } -> Hash

ブロックを評価した結果をキー、対応する要素を値とするハッシュを返します。 

(1..6).group_by {|i| i%3}   #=> {0=>[3, 6], 1=>[1, 4], 2=>[2, 5]}
member?(val) -> bool
include?(val) -> bool

val と == の関係にある要素を含むとき真を返します。

[PARAM] val:
任意のオブジェクト
inject(init = self.first) {|result, item| ... } -> object
inject(sym)
inject(init, sym)
reduce(init = self.first) {|result, item| ... } -> object
reduce(sym)
reduce(init, sym)

リストのたたみこみ演算を行います。

最初に初期値 init と self の最初の要素を引数にブロックを実行します。 2 回目以降のループでは、前のブロックの実行結果と self の次の要素を引数に順次ブロックを実行します。 そうして最後の要素まで繰り返し、最後のブロックの実行結果を返します。

要素が存在しない場合は init を返します。

初期値 init を省略した場合は、 最初に先頭の要素と 2 番目の要素をブロックに渡します。 また要素が 1 つしかなければブロックを実行せずに最初の要素を返します。 要素がなければブロックを実行せずに nil を返します。

[PARAM] init:
最初の result の値です。任意のオブジェクトが渡せます。
[PARAM] sym:
ブロックの代わりに使われるメソッド名を表す Symbol オブジェクトを指定します。 実行結果に対して sym という名前のメソッドが呼ばれます。

例: 

# 合計を計算する
p [1, 2, 3, 4, 5].inject(0) {|result, item| result + item }  # => 15

この式は以下のように書いても同じ結果が得られます。 

result = 0
[1, 2, 3, 4, 5].each {|v| result += v }
p result   # => 15

p [1, 2, 3, 4, 5].inject(:+)                    #=> 15
p ["b", "c", "d"].inject("abbccddde", :squeeze) #=> "abcde"
max -> object

最大の要素を返します。 全要素が互いに <=> メソッドで比較できることを仮定しています。

要素が存在しなければ nil を返します。

max {|a, b| ... } -> object

ブロックの評価結果で各要素の大小判定を行い、最大の要素を返します。 要素が存在しなければ nil を返します。

ブロックの値は、a > b のとき正、 a == b のとき 0、a < b のとき負の整数を、期待しています。 ブロックが整数以外を返したときは 例外 TypeError が発生します。

[EXCEPTION] TypeError:
ブロックが整数以外を返したときに発生します。
max_by -> Enumerator
max_by {|item| ... } -> object

各要素を順番にブロックに渡して実行し、 その評価結果を <=> で比較して、 最大であった値に対応する元の要素を返します。

要素が存在しないときは nil を返します。

Enumerable#max と Enumerable#max_by の 違いは Enumerable#sort と Enumerable#sort_by の違いと同じです。

[SEE_ALSO] Enumerable#sort_by

min -> object

最小の要素を返します。 全要素が互いに <=> メソッドで比較できることを仮定しています。

要素が存在しなければ nil を返します。

min {|a, b| ... } -> object

ブロックの評価結果で各要素の大小判定を行い、最小の要素を返します。 要素が存在しなければ nil を返します。

ブロックの値は、a > b のとき正、a == b のとき 0、 a < b のとき負の整数を、期待しています。 ブロックが整数以外を返したときは例外 TypeError が発生します。

[EXCEPTION] TypeError:
ブロックが整数以外を返したとき
min_by -> Enumerator
min_by {|item| ... } -> object

各要素を順番にブロックに渡して実行し、 その評価結果を <=> で比較して、 最大であった値に対応する元の要素を返します。

要素が存在しないときは nil を返します。

Enumerable#min と Enumerable#min_by の 違いは Enumerable#sort と [[n:Enumerable#sort_by]] の違いと同じです。

[SEE_ALSO] Enumerable#sort_by

minmax -> [min, max]
minmax {|a, b| ... } -> [min, max]

Enumerable オブジェクトの各要素のうち最小の要素と最大の要素を 要素とするサイズ 2 の配列を返します。

一つ目の形式は、Enumerable オブジェクトのすべての要素が Comparable を 実装していることを仮定しています。二つ目の形式では、要素同士の比較を ブロックを用いて行います。 

a = %w(albatross dog horse)
a.minmax                                 #=> ["albatross", "horse"]
a.minmax{|a,b| a.length <=> b.length }   #=> ["dog", "albatross"]

[SEE_ALSO] Enumerable#sort

minmax_by -> Enumerator
minmax_by {|obj| ... } -> [min, max]

Enumerable オブジェクトの各要素のうち最小の要素と最大の要素を 要素とするサイズ 2 の配列を返します。

Enumerable#minmax と Enumerable#minmax_by の 違いは sort と sort_by の違いと同じです。 詳細は Enumerable#sort_by を参照してください。 

a = %w(albatross dog horse)
a.minmax_by {|x| x.length }   #=> ["dog", "albatross"]

[SEE_ALSO] Enumerable#sort_by

none? -> bool
none? {|obj| ... } -> bool

ブロックを指定しない場合は、 Enumerable オブジェクトのすべての 要素が偽であれば真を返します。そうでなければ偽を返します。

ブロックを指定した場合は、Enumerable オブジェクトのすべての要素を ブロックで評価した結果が、すべて偽であれば真を返します。 そうでなければ偽を返します。 

%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
one? -> bool
one? {|obj| ... } -> bool

ブロックを指定しない場合は、 Enumerable オブジェクトの要素のうち ちょうど一つだけが真であれば、真を返します。 そうでなければ偽を返します。

ブロックを指定した場合は、Enumerable オブジェクトの要素を ブロックで評価した結果、一つの要素だけが真であれば真を返します。 そうでなければ偽を返します。 

%w{ant bear cat}.one? {|word| word.length == 4}   #=> true
%w{ant bear cat}.one? {|word| word.length >= 4}   #=> false
[ nil, true, 99 ].one?                            #=> false
[ nil, true, false ].one?                         #=> true
partition -> Enumerator
partition {|item| ... } -> [[object], [object]]

各要素を、ブロックの条件を満たす要素と満たさない要素に分割します。 各要素に対してブロックを評価して、その値が真であった要素の配列と、 偽であった要素の配列の 2 つを配列に入れて返します。

例: 

[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]]
reject -> Enumerator
reject {|item| ... } -> [object]

各要素に対してブロックを評価し、 その値が偽であった要素を集めた新しい配列を返します。 条件を反転させた select です。

例: 

# 偶数を除外する (奇数を集める)
[1, 2, 3, 4, 5, 6].reject {|i| i % 2 == 0 }  # => [1, 3, 5]

[SEE_ALSO] Enumerable#select

sort -> [object]
sort {|a, b| ... } -> [object]

全ての要素を昇順にソートした配列を生成して返します。

ブロックなしのときは <=> メソッドを要素に対して呼び、 その結果をもとにソートします。

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

Enumerable#sort は安定ではありません (unstable sort)。 安定なソートが必要な場合は Enumerable#sort_by を使って工夫する必要があります。 詳しくは Enumerable#sort_by の項目を参照してください。

※ 比較結果が同じ要素は元の順序通りに並ぶソートを 「安定なソート (stable sort)」と言います。

[SEE_ALSO] Enumerable#sort_by

sort_by -> Enumerator
sort_by {|item| ... } -> [object]

ブロックの評価結果を <=> メソッドで比較することで、self を昇 順にソートします。ソートされた配列を新たに生成して返します。 つまり、以下とほぼ同じ動作をします。 

class Array
  def sort_by
    self.map {|i| [yield(i), i] }.
       sort {|a, b| a[0] <=> b[0] }.
       map {|i| i[1]}
  end
end

Enumerable#sort と比較して sort_by が優れている点として、 比較条件が複雑な場合の速度が挙げられます。 sort_by を使わない以下の例では比較を行う度に downcase が実行されます。 従って downcase の実行速度が遅ければ sort の速度が致命的に低下します。 

p ["BAR", "FOO", "bar", "foo"].sort {|a, b| a.downcase <=> b.downcase }

一方、次のように sort_by を使うと downcase の実行回数は要素数と同じです。 つまり、その部分の実行時間は O(n) のオーダーです。 

p ["BAR", "FOO", "bar", "foo"].sort_by {|v| v.downcase }

以下の、実行回数の検証結果を参照してみてください。 

class Integer
  def count
    $n += 1
    self
  end
end

ary = []
1.upto(1000) {|v| ary << rand(v) }

$n = 0
ary.sort {|a,b| a.count <=> b.count }
p $n          # => 18200

$n = 0
ary.sort_by {|v| v.count }
p $n          # => 1000

Enumerable#sort_by は安定ではありません (unstable sort)。 ただし、sort_by を以下のように使うと安定なソートを実装できます。 

i = 0
ary.sort_by {|v| [v, i += 1] }

※ 比較結果が同じ要素は元の順序通りに並ぶソートを 「安定なソート (stable sort)」と言います。

[SEE_ALSO] Enumerable#sort

take(n) -> Array

Enumerable オブジェクトの先頭から n 要素を配列として返します。 

a = [1, 2, 3, 4, 5, 0]
a.take(3)             # => [1, 2, 3]
take_while -> Enumerator
take_while {|element| ... } -> Array

Enumerable オブジェクトの要素を順に偽になるまでブロックで評価します。 最初に偽になった要素の手前の要素までを配列として返します。 

a = [1, 2, 3, 4, 5, 0]
a.take_while {|i| i < 3 }   # => [1, 2]
zip(*lists) -> [[object]]

self と引数に渡した配列の各要素からなる配列の配列を生成して返します。 生成される配列の要素数は self の要素数と同じです。

[PARAM] lists:
配列を指定します。配列でない場合は to_a メソッドにより配列に変換します。

例: 

p [1,2,3].zip([4,5,6], [7,8,9])
    # => [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

p [1,2].zip([:a,:b,:c], [:A,:B,:C,:D])
    # => [[1, :a, :A], [2, :b, :B]]

p (1..5).zip([:a,:b,:c], [:A,:B,:C,:D])
    # => [[1, :a, :A], [2, :b, :B],
    #     [3, :c, :C], [4, nil, :D], [5, nil, nil]]
zip(*lists) {|v1, v2, ...| ...} -> nil

zip をブロック付きで呼び出した場合は、 self と引数に渡した配列の各要素を順番にブロックに渡します。

常に nil を返します。

[PARAM] lists:
配列を指定します。配列でない場合は to_a メソッドにより配列に変換します。

例: 

p [1,2,3].zip([4,5,6], [7,8,9]) {|ary|
  p ary
}
    # => [1, 4, 7]
    #    [2, 5, 8]
    #    [3, 6, 9]
    #    nil

追加されるメソッド

to_set(klass = Set, *args) -> Set [added by set]
to_set(klass = Set, *args) {|o| ... } -> Set [added by set]

Enumerable オブジェクトの要素から、新しい集合オブジェクトを作ります。

引数 klass を与えた場合、Set クラスの代わりに、指定した集合クラスの インスタンスを作ります。 この引数を指定することで、SortedSet あるいはその他のユーザ定義の 集合クラスのインスタンスを作ることができます。

引数 args およびブロックは、集合オブジェクトを生成するための new メソッドに渡されます。

[PARAM] klass:
生成する集合クラスを指定します。
[PARAM] args:
集合クラスのオブジェクト初期化メソッドに渡す引数を指定します。
[PARAM] block:
集合クラスのオブジェクト初期化メソッドに渡すブロックを指定します。
[RETURN]
生成された集合オブジェクトを返します。 
p [10, 20, 30].to_set
#=> #<Set: {30, 20, 10}>
p [10, 20, 30].to_set(SortedSet)
#=> #<SortedSet: {10, 20, 30}>
p [10, 20, 30].to_set {|num| num / 10}
#=> #<Set: {1, 2, 3}>

[SEE_ALSO] Set.new

Methods

Classes