るりまサーチ (Ruby 2.2.0)

最速Rubyリファレンスマニュアル検索!
108件ヒット [1-100件を表示] (0.013秒)
トップページ > バージョン:2.2.0[x] > モジュール:Enumerable[x]

ライブラリ

キーワード

検索結果

<< 1 2 > >>

Enumerable#all? -> bool (2.0)

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

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

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

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

Enumerable#all? {|item| ... } -> bool (2.0)

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

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

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

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

Enumerable#any? -> bool (2.0)

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

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

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

例:
p [1, 2, 3].any? {|v| v > 3 } # => false
p [1, 2, 3].any? {|v| v > 1 } # => true
p [].any? {|v| v > 0 } # => false

Enumerable#any? {|item| ... } -> bool (2.0)

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

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

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

例:
p [1, 2, 3].any? {|v| v > 3 } # => false
p [1, 2, 3].any? {|v| v > 1 } # => true
p [].any? {|v| v > 0 } # => false

Enumerable#chunk {|elt| ... } -> Enumerator (2.0)

要素を前から順にブロックで評価し、その結果によって 要素をチャンクに分けた(グループ化した)要素を持つ Enumerator を返します。

要素を前から順にブロックで評価し、その結果によって
要素をチャンクに分けた(グループ化した)要素を持つ
Enumerator を返します。

ブロックの評価値が同じ値が続くものを一つのチャンクとして
取り扱います。すなわち、ブロックの評価値が一つ前と
異なる所でチャンクが区切られます。

返り値の Enumerator は各チャンクのブロック評価値と
各チャンクの要素を持つ配列のペアを各要素とします。
そのため、eachだと以下のようになります。

enum.chunk {|elt| key }.each {|key, ary| ... }
enum.chunk(initial_st...

絞り込み条件を変える

Enumerable#chunk(initial_state) {|elt, state| ... } -> Enumerator (2.0)

要素を前から順にブロックで評価し、その結果によって 要素をチャンクに分けた(グループ化した)要素を持つ Enumerator を返します。

要素を前から順にブロックで評価し、その結果によって
要素をチャンクに分けた(グループ化した)要素を持つ
Enumerator を返します。

ブロックの評価値が同じ値が続くものを一つのチャンクとして
取り扱います。すなわち、ブロックの評価値が一つ前と
異なる所でチャンクが区切られます。

返り値の Enumerator は各チャンクのブロック評価値と
各チャンクの要素を持つ配列のペアを各要素とします。
そのため、eachだと以下のようになります。

enum.chunk {|elt| key }.each {|key, ary| ... }
enum.chunk(initial_st...

Enumerable#collect -> Enumerator (2.0)

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

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

ブロックを省略した場合、上で説明した繰り返しを実行し、その結果として
得られる配列を返すような Enumerator オブジェクトを返します。

例:
# すべて 3 倍にする
p [1, 2, 3].map {|n| n * 3 } # => [3, 6, 9]

Enumerable#collect {|item| ... } -> [object] (2.0)

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

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

ブロックを省略した場合、上で説明した繰り返しを実行し、その結果として
得られる配列を返すような Enumerator オブジェクトを返します。

例:
# すべて 3 倍にする
p [1, 2, 3].map {|n| n * 3 } # => [3, 6, 9]

Enumerable#collect_concat -> Enumerator (2.0)

各要素をブロックに渡し、その返り値を連結した配列を返します。

各要素をブロックに渡し、その返り値を連結した配列を返します。

ブロックの返り値は基本的に配列を返すべきです。

ブロックを省略した場合は、ブロックを受けとり
上で説明した評価をし、その結果の配列を返す
Enumerator オブジェクトを返します。

[[1,2], [3,4]].flat_map{|i| i.map{|j| j*2}} # => [2,4,6,8]

Enumerable#collect_concat {| obj | block } -> Array (2.0)

各要素をブロックに渡し、その返り値を連結した配列を返します。

各要素をブロックに渡し、その返り値を連結した配列を返します。

ブロックの返り値は基本的に配列を返すべきです。

ブロックを省略した場合は、ブロックを受けとり
上で説明した評価をし、その結果の配列を返す
Enumerator オブジェクトを返します。

[[1,2], [3,4]].flat_map{|i| i.map{|j| j*2}} # => [2,4,6,8]

絞り込み条件を変える

Enumerable#count -> Integer (2.0)

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

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

引数を指定しない場合は、レシーバの要素数を返します。
このとき、
要素数を一つずつカウントします。

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

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

@param item カウント対象となる値。

例:

ary = [1, 2, 4, 2]
ary.count # => 4
ary.count(2) # => 2
ar...

Enumerable#count {|obj| ... } -> Integer (2.0)

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

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

引数を指定しない場合は、レシーバの要素数を返します。
このとき、
要素数を一つずつカウントします。

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

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

@param item カウント対象となる値。

例:

ary = [1, 2, 4, 2]
ary.count # => 4
ary.count(2) # => 2
ar...

Enumerable#count(item) -> Integer (2.0)

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

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

引数を指定しない場合は、レシーバの要素数を返します。
このとき、
要素数を一つずつカウントします。

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

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

@param item カウント対象となる値。

例:

ary = [1, 2, 4, 2]
ary.count # => 4
ary.count(2) # => 2
ar...

Enumerable#cycle(n=nil) -> Enumerator (2.0)

Enumerable オブジェクトの各要素を n 回 or 無限回(n=nil)繰り返し ブロックを呼びだします。

...Enumerable オブジェクトの各要素を n 回 or 無限回(n=nil)繰り返し
ブロックを呼びだします。

n に 0 もしくは負の値を渡した場合は何もしません。
繰り返しが最後まで終了した場合(つまりbreakなどで中断しなかった場合)
は nil...
...を返します。
このメソッドは内部の配列に各要素を保存しておくため、
一度 Enumerable の終端に到達した後に自分自身を変更しても
このメソッドの動作に影響を与えません。

a = ["a", "b", "c"]
a.cycle {|x| puts x } # print, a, b, c,...

Enumerable#cycle(n=nil) {|obj| ... } -> object | nil (2.0)

Enumerable オブジェクトの各要素を n 回 or 無限回(n=nil)繰り返し ブロックを呼びだします。

...Enumerable オブジェクトの各要素を n 回 or 無限回(n=nil)繰り返し
ブロックを呼びだします。

n に 0 もしくは負の値を渡した場合は何もしません。
繰り返しが最後まで終了した場合(つまりbreakなどで中断しなかった場合)
は nil...
...を返します。
このメソッドは内部の配列に各要素を保存しておくため、
一度 Enumerable の終端に到達した後に自分自身を変更しても
このメソッドの動作に影響を与えません。

a = ["a", "b", "c"]
a.cycle {|x| puts x } # print, a, b, c,...

絞り込み条件を変える

Enumerable#detect(ifnone = nil) -> Enumerator (2.0)

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

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

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

ブロックを省略した場合は、各要素に対しブロックを真になるまで評価し、最初に
真になった値を返すような Enumerator を返します。

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

例:
# 最初の 3 の倍数を探す
p [1, 2, 3, ...

Enumerable#detect(ifnone = nil) {|item| ... } -> object (2.0)

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

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

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

ブロックを省略した場合は、各要素に対しブロックを真になるまで評価し、最初に
真になった値を返すような Enumerator を返します。

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

例:
# 最初の 3 の倍数を探す
p [1, 2, 3, ...

Enumerable#drop(n) -> Array (2.0)

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

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

@param n 捨てる要素数。

a = [1, 2, 3, 4, 5, 0]
a.drop(3) # => [4, 5, 0]...

Enumerable#drop_while -> Enumerator (2.0)

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

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

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

a = [1, 2, 3, 4, 5, 0]
a.drop_while {|i| i < 3 } # => [3, 4, 5, 0]

Enumerable#drop_while {|element| ... } -> Array (2.0)

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

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

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

a = [1, 2, 3, 4, 5, 0]
a.drop_while {|i| i < 3 } # => [3, 4, 5, 0]

絞り込み条件を変える

Enumerable#each_cons(n) -> Enumerator (2.0)

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

...素数より大きな数を与えると、ブロックは一度も実行されません。

例:

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

@see Enumerable#each_slice...

Enumerable#each_cons(n) {|list| ... } -> nil (2.0)

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

...素数より大きな数を与えると、ブロックは一度も実行されません。

例:

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

@see Enumerable#each_slice...

Enumerable#each_entry -> Enumerator (2.0)

ブロックを各要素に一度ずつ適用します。

...列として渡されます。

class Foo
include Enumerable
def each
yield 1
yield 1,2
end
end
Foo.new.each_entry{|o| print o, " -- "}
# => 1 -- [1, 2] --

ブロックを省略した場合は Enumerator が返されます。

@see Enumerable#slice_before...

Enumerable#each_entry {|obj| block} -> self (2.0)

ブロックを各要素に一度ずつ適用します。

...列として渡されます。

class Foo
include Enumerable
def each
yield 1
yield 1,2
end
end
Foo.new.each_entry{|o| print o, " -- "}
# => 1 -- [1, 2] --

ブロックを省略した場合は Enumerator が返されます。

@see Enumerable#slice_before...

Enumerable#each_slice(n) -> Enumerator (2.0)

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

...ブロックを省略した場合は
n 要素ずつ繰り返す Enumerator を返します。

@param n 区切る要素数を示す整数です。

例:

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

@see Enumerable#each_cons...

絞り込み条件を変える

Enumerable#each_slice(n) {|list| ... } -> nil (2.0)

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

...ブロックを省略した場合は
n 要素ずつ繰り返す Enumerator を返します。

@param n 区切る要素数を示す整数です。

例:

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

@see Enumerable#each_cons...

Enumerable#each_with_index -> Enumerator (2.0)

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

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

self を返します。

ブロックを省略した場合は、
要素とそのインデックスを繰り返すような
Enumerator を返します。

例:
[5, 10, 15].each_with_index do |n, idx|
p [n, idx]
end
# => [5, 0]
# [10, 1]
# [15, 2]

Enumerable#each_with_index {|item, index| ... } -> self (2.0)

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

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

self を返します。

ブロックを省略した場合は、
要素とそのインデックスを繰り返すような
Enumerator を返します。

例:
[5, 10, 15].each_with_index do |n, idx|
p [n, idx]
end
# => [5, 0]
# [10, 1]
# [15, 2]

Enumerable#each_with_object(obj) -> Enumerator (2.0)

与えられた任意のオブジェクトと要素をブロックに渡し繰り返し、最初に与えられたオブジェクトを返します。

与えられた任意のオブジェクトと要素をブロックに渡し繰り返し、最初に与えられたオブジェクトを返します。

ブロックを省略した場合は、上の繰り返しをして、最初に与えたオブジェクトを
最後に返す Enumerator を返します。

@param obj 任意のオブジェクトを指定します。

evens = (1..10).each_with_object([]) {|i, a| a << i*2 }
# => [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

@see Enumerator#with_object

Enumerable#each_with_object(obj) {|(*args), memo_obj| ... } -> object (2.0)

与えられた任意のオブジェクトと要素をブロックに渡し繰り返し、最初に与えられたオブジェクトを返します。

与えられた任意のオブジェクトと要素をブロックに渡し繰り返し、最初に与えられたオブジェクトを返します。

ブロックを省略した場合は、上の繰り返しをして、最初に与えたオブジェクトを
最後に返す Enumerator を返します。

@param obj 任意のオブジェクトを指定します。

evens = (1..10).each_with_object([]) {|i, a| a << i*2 }
# => [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

@see Enumerator#with_object

絞り込み条件を変える

Enumerable#entries(*args) -> [object] (2.0)

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

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

@param args each の呼び出し時に引数として渡されます。

Enumerable#find(ifnone = nil) -> Enumerator (2.0)

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

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

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

ブロックを省略した場合は、各要素に対しブロックを真になるまで評価し、最初に
真になった値を返すような Enumerator を返します。

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

例:
# 最初の 3 の倍数を探す
p [1, 2, 3, ...

Enumerable#find(ifnone = nil) {|item| ... } -> object (2.0)

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

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

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

ブロックを省略した場合は、各要素に対しブロックを真になるまで評価し、最初に
真になった値を返すような Enumerator を返します。

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

例:
# 最初の 3 の倍数を探す
p [1, 2, 3, ...

Enumerable#find_all -> Enumerator (2.0)

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

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

ブロックを省略した場合は、各要素に対しブロックを評価し
真になった値の配列を返すような Enumerator を返します。

Enumerable#find_all {|item| ... } -> [object] (2.0)

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

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

ブロックを省略した場合は、各要素に対しブロックを評価し
真になった値の配列を返すような Enumerator を返します。

絞り込み条件を変える

Enumerable#find_index -> Enumerator (2.0)

条件に一致する最初の要素の位置を返します。

条件に一致する最初の要素の位置を返します。

@param val 位置を知りたいオブジェクトを指定します。

指定された val と == で等しい最初の要素の位置を返します。
等しい要素がひとつもなかった場合は nil を返します。

(1..10).find_index(11) #=> nil
(1..10).find_index(2) #=> 1

ブロックが与えられた場合には、各要素を引数として先頭から順にブロックを実行し、
ブロックが真を返した最初の要素の位置を返します。
一つも真にならなかった場合は nil を返します。

(1..10).find_i...

Enumerable#find_index {|obj| ... } -> Integer | nil (2.0)

条件に一致する最初の要素の位置を返します。

条件に一致する最初の要素の位置を返します。

@param val 位置を知りたいオブジェクトを指定します。

指定された val と == で等しい最初の要素の位置を返します。
等しい要素がひとつもなかった場合は nil を返します。

(1..10).find_index(11) #=> nil
(1..10).find_index(2) #=> 1

ブロックが与えられた場合には、各要素を引数として先頭から順にブロックを実行し、
ブロックが真を返した最初の要素の位置を返します。
一つも真にならなかった場合は nil を返します。

(1..10).find_i...

Enumerable#find_index(val) -> Integer | nil (2.0)

条件に一致する最初の要素の位置を返します。

条件に一致する最初の要素の位置を返します。

@param val 位置を知りたいオブジェクトを指定します。

指定された val と == で等しい最初の要素の位置を返します。
等しい要素がひとつもなかった場合は nil を返します。

(1..10).find_index(11) #=> nil
(1..10).find_index(2) #=> 1

ブロックが与えられた場合には、各要素を引数として先頭から順にブロックを実行し、
ブロックが真を返した最初の要素の位置を返します。
一つも真にならなかった場合は nil を返します。

(1..10).find_i...

Enumerable#first -> object | nil (2.0)

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

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

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

@param n 取得する要...

Enumerable#first(n) -> Array (2.0)

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

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

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

@param n 取得する要...

絞り込み条件を変える

Enumerable#flat_map -> Enumerator (2.0)

各要素をブロックに渡し、その返り値を連結した配列を返します。

各要素をブロックに渡し、その返り値を連結した配列を返します。

ブロックの返り値は基本的に配列を返すべきです。

ブロックを省略した場合は、ブロックを受けとり
上で説明した評価をし、その結果の配列を返す
Enumerator オブジェクトを返します。

[[1,2], [3,4]].flat_map{|i| i.map{|j| j*2}} # => [2,4,6,8]

Enumerable#flat_map {| obj | block } -> Array (2.0)

各要素をブロックに渡し、その返り値を連結した配列を返します。

各要素をブロックに渡し、その返り値を連結した配列を返します。

ブロックの返り値は基本的に配列を返すべきです。

ブロックを省略した場合は、ブロックを受けとり
上で説明した評価をし、その結果の配列を返す
Enumerator オブジェクトを返します。

[[1,2], [3,4]].flat_map{|i| i.map{|j| j*2}} # => [2,4,6,8]

Enumerable#grep(pattern) -> [object] (2.0)

pattern === item が成立する要素を全て含んだ配列を返します。

pattern === item が成立する要素を全て含んだ配列を返します。

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

@param pattern 「===」メソッドを持つオブジェクトを指定します。

例:
['aa', 'bb', 'cc', 'dd', 'ee'].grep(/[bc]/) # => ["bb", "cc"]

Array.instance_methods.grep(/gr/) # => [:grep, :group_b...

Enumerable#grep(pattern) {|item| ... } -> [object] (2.0)

pattern === item が成立する要素を全て含んだ配列を返します。

pattern === item が成立する要素を全て含んだ配列を返します。

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

@param pattern 「===」メソッドを持つオブジェクトを指定します。

例:
['aa', 'bb', 'cc', 'dd', 'ee'].grep(/[bc]/) # => ["bb", "cc"]

Array.instance_methods.grep(/gr/) # => [:grep, :group_b...

Enumerable#group_by -> Enumerator (2.0)

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

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


(1..6).group_by {|i| i%3} #=> {0=>[3, 6], 1=>[1, 4], 2=>[2, 5]}

ブロックを省略した場合は、最後に Hash を返す
Enumerator オブジェクトを返します。

絞り込み条件を変える

Enumerable#group_by {|obj| ... } -> Hash (2.0)

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

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


(1..6).group_by {|i| i%3} #=> {0=>[3, 6], 1=>[1, 4], 2=>[2, 5]}

ブロックを省略した場合は、最後に Hash を返す
Enumerator オブジェクトを返します。

Enumerable#include?(val) -> bool (2.0)

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

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

@param val 任意のオブジェクト

Enumerable#inject(init = self.first) {|result, item| ... } -> object (2.0)

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

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

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

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

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

@param in...

Enumerable#inject(init, sym) -> object (2.0)

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

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

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

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

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

@param in...

Enumerable#inject(sym) -> object (2.0)

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

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

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

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

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

@param in...

絞り込み条件を変える

Enumerable#lazy -> Enumerator::Lazy (2.0)

自身を lazy な Enumerator に変換したものを返します。

自身を lazy な Enumerator に変換したものを返します。

この Enumerator は、以下のメソッドが遅延評価を行う (つまり、配列ではな
くEnumeratorを返す) ように再定義されています。

* map/collect
* flat_map/collect_concat
* select/find_all
* reject
* grep
* take, take_while
* drop, drop_while
* zip (※一貫性のため、ブロックを渡さないケースのみlazy)
* cycle (※一貫性のため、ブロックを渡さないケースのみl...

Enumerable#map -> Enumerator (2.0)

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

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

ブロックを省略した場合、上で説明した繰り返しを実行し、その結果として
得られる配列を返すような Enumerator オブジェクトを返します。

例:
# すべて 3 倍にする
p [1, 2, 3].map {|n| n * 3 } # => [3, 6, 9]

Enumerable#map {|item| ... } -> [object] (2.0)

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

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

ブロックを省略した場合、上で説明した繰り返しを実行し、その結果として
得られる配列を返すような Enumerator オブジェクトを返します。

例:
# すべて 3 倍にする
p [1, 2, 3].map {|n| n * 3 } # => [3, 6, 9]

Enumerable#max -> object | nil (2.0)

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

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

引数を指定しない形式では要素が存在しなければ nil を返します。
引数を指定する形式では、空の配列を返します。
該当する要素が複数存在する場合、どの要素を返すかは不定です。

@param n 取得する要素数。

Enumerable#max {|a, b| ... } -> object | nil (2.0)

ブロックの評価結果で各要素の大小判定を行い、最大の要素、もしくは最小の n 要素を返します。 引数を指定しない形式では要素が存在しなければ nil を返します。 引数を指定する形式では、空の配列を返します。

ブロックの評価結果で各要素の大小判定を行い、最大の要素、もしくは最小の
n 要素を返します。
引数を指定しない形式では要素が存在しなければ nil を返します。
引数を指定する形式では、空の配列を返します。

ブロックの値は、a > b のとき正、
a == b のとき 0、a < b のとき負の整数を、期待しています。

該当する要素が複数存在する場合、どの要素を返すかは不定です。

@param n 取得する要素数。

@raise TypeError ブロックが整数以外を返したときに発生します。

絞り込み条件を変える

Enumerable#max(n) -> Array (2.0)

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

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

引数を指定しない形式では要素が存在しなければ nil を返します。
引数を指定する形式では、空の配列を返します。
該当する要素が複数存在する場合、どの要素を返すかは不定です。

@param n 取得する要素数。

Enumerable#max(n) {|a, b| ... } -> Array (2.0)

ブロックの評価結果で各要素の大小判定を行い、最大の要素、もしくは最小の n 要素を返します。 引数を指定しない形式では要素が存在しなければ nil を返します。 引数を指定する形式では、空の配列を返します。

ブロックの評価結果で各要素の大小判定を行い、最大の要素、もしくは最小の
n 要素を返します。
引数を指定しない形式では要素が存在しなければ nil を返します。
引数を指定する形式では、空の配列を返します。

ブロックの値は、a > b のとき正、
a == b のとき 0、a < b のとき負の整数を、期待しています。

該当する要素が複数存在する場合、どの要素を返すかは不定です。

@param n 取得する要素数。

@raise TypeError ブロックが整数以外を返したときに発生します。

Enumerable#max_by -> Enumerator (2.0)

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

...合、どの要素を返すかは不定です。

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

ブロックを省略した場合は Enumerator を返します。

@param n 取得する要素数。

@see Enumerable#sort_by...

Enumerable#max_by {|item| ... } -> object | nil (2.0)

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

...合、どの要素を返すかは不定です。

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

ブロックを省略した場合は Enumerator を返します。

@param n 取得する要素数。

@see Enumerable#sort_by...

Enumerable#max_by(n) -> Enumerator (2.0)

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

...合、どの要素を返すかは不定です。

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

ブロックを省略した場合は Enumerator を返します。

@param n 取得する要素数。

@see Enumerable#sort_by...

絞り込み条件を変える

Enumerable#max_by(n) {|item| ... } -> Array (2.0)

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

...合、どの要素を返すかは不定です。

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

ブロックを省略した場合は Enumerator を返します。

@param n 取得する要素数。

@see Enumerable#sort_by...

Enumerable#member?(val) -> bool (2.0)

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

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

@param val 任意のオブジェクト

Enumerable#min -> object | nil (2.0)

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

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

引数を指定しない形式では要素が存在しなければ nil を返します。
引数を指定する形式では、空の配列を返します。
該当する要素が複数存在する場合、どの要素を返すかは不定です。

@param n 取得する要素数。

Enumerable#min {|a, b| ... } -> object | nil (2.0)

ブロックの評価結果で各要素の大小判定を行い、最小の要素、もしくは最小の n 要素を返します。 引数を指定しない形式では要素が存在しなければ nil を返します。 引数を指定する形式では、空の配列を返します。

ブロックの評価結果で各要素の大小判定を行い、最小の要素、もしくは最小の
n 要素を返します。
引数を指定しない形式では要素が存在しなければ nil を返します。
引数を指定する形式では、空の配列を返します。

ブロックの値は、a > b のとき正、a == b のとき 0、
a < b のとき負の整数を、期待しています。

該当する要素が複数存在する場合、どの要素を返すかは不定です。

@param n 取得する要素数。

@raise TypeError ブロックが整数以外を返したときに発生します。

Enumerable#min(n) -> Array (2.0)

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

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

引数を指定しない形式では要素が存在しなければ nil を返します。
引数を指定する形式では、空の配列を返します。
該当する要素が複数存在する場合、どの要素を返すかは不定です。

@param n 取得する要素数。

絞り込み条件を変える

Enumerable#min(n) {|a, b| ... } -> Array (2.0)

ブロックの評価結果で各要素の大小判定を行い、最小の要素、もしくは最小の n 要素を返します。 引数を指定しない形式では要素が存在しなければ nil を返します。 引数を指定する形式では、空の配列を返します。

ブロックの評価結果で各要素の大小判定を行い、最小の要素、もしくは最小の
n 要素を返します。
引数を指定しない形式では要素が存在しなければ nil を返します。
引数を指定する形式では、空の配列を返します。

ブロックの値は、a > b のとき正、a == b のとき 0、
a < b のとき負の整数を、期待しています。

該当する要素が複数存在する場合、どの要素を返すかは不定です。

@param n 取得する要素数。

@raise TypeError ブロックが整数以外を返したときに発生します。

Enumerable#min_by -> Enumerator (2.0)

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

...合、どの要素を返すかは不定です。

ブロックを省略した場合は Enumerator を返します。

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

@param n 取得する要素数。

@see Enumerable#sort_by...

Enumerable#min_by {|item| ... } -> object | nil (2.0)

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

...合、どの要素を返すかは不定です。

ブロックを省略した場合は Enumerator を返します。

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

@param n 取得する要素数。

@see Enumerable#sort_by...

Enumerable#min_by(n) -> Enumerator (2.0)

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

...合、どの要素を返すかは不定です。

ブロックを省略した場合は Enumerator を返します。

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

@param n 取得する要素数。

@see Enumerable#sort_by...

Enumerable#min_by(n) {|item| ... } -> Array (2.0)

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

...合、どの要素を返すかは不定です。

ブロックを省略した場合は Enumerator を返します。

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

@param n 取得する要素数。

@see Enumerable#sort_by...

絞り込み条件を変える

Enumerable#minmax -> [object, object] (2.0)

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

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

該当する要素が複数存在する場合、どの要素を返すかは不定です。

一つ目の形式は、Enumerable オブジェクトのすべ...
...では、要素同士の比較を
ブロックを用いて行います。

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

@see Enumerable#sort...

Enumerable#minmax {|a, b| ... } -> [object, object] (2.0)

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

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

該当する要素が複数存在する場合、どの要素を返すかは不定です。

一つ目の形式は、Enumerable オブジェクトのすべ...
...では、要素同士の比較を
ブロックを用いて行います。

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

@see Enumerable#sort...

Enumerable#minmax_by -> Enumerator (2.0)

Enumerable オブジェクトの各要素をブロックに渡して評価し、その結果を <=> で比較して 最小の要素と最大の要素を要素とするサイズ 2 の配列を返します。

...
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"]

[].minmax_by{} # => [nil, nil]

ブロッ...
...クを省略した場合は、Enumerator オブジェクトを
返します。

@see Enumerable#sort_by...

Enumerable#minmax_by {|obj| ... } -> [object, object] (2.0)

Enumerable オブジェクトの各要素をブロックに渡して評価し、その結果を <=> で比較して 最小の要素と最大の要素を要素とするサイズ 2 の配列を返します。

...
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"]

[].minmax_by{} # => [nil, nil]

ブロッ...
...クを省略した場合は、Enumerator オブジェクトを
返します。

@see Enumerable#sort_by...

Enumerable#none? -> bool (2.0)

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

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

ブロックを指定した場合は、Enumerable オブジェクトのすべての要素を
ブロックで評価した...

絞り込み条件を変える

Enumerable#none? {|obj| ... } -> bool (2.0)

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

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

ブロックを指定した場合は、Enumerable オブジェクトのすべての要素を
ブロックで評価した...

Enumerable#one? -> bool (2.0)

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

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

ブロックを指定した場合は、Enumerable オブジェクトの要素を
ブロックで...

Enumerable#one? {|obj| ... } -> bool (2.0)

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

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

ブロックを指定した場合は、Enumerable オブジェクトの要素を
ブロックで...

Enumerable#partition -> Enumerator (2.0)

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

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

ブロックを省略した場合は、各要素に対しブロックを評価し、
上のようにその値が真であった要素の配列と、
偽であった要素の配列のペアを返すような Enumerator を
返します。

例:

[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, ...

Enumerable#partition {|item| ... } -> [[object], [object]] (2.0)

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

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

ブロックを省略した場合は、各要素に対しブロックを評価し、
上のようにその値が真であった要素の配列と、
偽であった要素の配列のペアを返すような Enumerator を
返します。

例:

[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, ...

絞り込み条件を変える

Enumerable#reduce(init = self.first) {|result, item| ... } -> object (2.0)

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

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

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

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

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

@param in...

Enumerable#reduce(init, sym) -> object (2.0)

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

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

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

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

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

@param in...

Enumerable#reduce(sym) -> object (2.0)

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

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

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

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

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

@param in...

Enumerable#reject -> Enumerator (2.0)

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

...ブロックを省略した場合は、各要素に対しブロックを評価し
偽になった値の配列を返すような Enumerator を返します。

例:

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

@see Enumerable#select...

Enumerable#reject {|item| ... } -> [object] (2.0)

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

...ブロックを省略した場合は、各要素に対しブロックを評価し
偽になった値の配列を返すような Enumerator を返します。

例:

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

@see Enumerable#select...

絞り込み条件を変える

Enumerable#reverse_each -> Enumerator (2.0)

逆順に各要素に対してブロックを評価します。

逆順に各要素に対してブロックを評価します。

内部で各要素を保持した配列を作ります。

ブロックを省略した場合は、各要素を逆順に辿る
Enumerator を返します。

Enumerable#reverse_each {|element| ... } -> self (2.0)

逆順に各要素に対してブロックを評価します。

逆順に各要素に対してブロックを評価します。

内部で各要素を保持した配列を作ります。

ブロックを省略した場合は、各要素を逆順に辿る
Enumerator を返します。

Enumerable#select -> Enumerator (2.0)

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

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

ブロックを省略した場合は、各要素に対しブロックを評価し
真になった値の配列を返すような Enumerator を返します。

Enumerable#select {|item| ... } -> [object] (2.0)

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

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

ブロックを省略した場合は、各要素に対しブロックを評価し
真になった値の配列を返すような Enumerator を返します。

Enumerable#slice_after {|elt| bool } -> Enumerator (2.0)

パターンがマッチした要素、もしくはブロックが真を返した要素を末尾の要素 としてチャンク化(グループ化)したものを繰り返す Enumerator を 返し ます。

...#=> [["foo\n"], ["bar\\\n", "baz\n"], ["\n"], ["qux\n"]]
p e.map {|ll| ll[0...-1].map {|l| l.sub(/\\\n\z/, "") }.join + ll.last }
#=>["foo\n", "barbaz\n", "\n", "qux\n"]

Enumerable
#map のようなメソッドを使うこともできます。

@see Enumerable#chunk, Enumerable#slice_before...

絞り込み条件を変える

Enumerable#slice_after(pattern) -> Enumerator (2.0)

パターンがマッチした要素、もしくはブロックが真を返した要素を末尾の要素 としてチャンク化(グループ化)したものを繰り返す Enumerator を 返し ます。

...#=> [["foo\n"], ["bar\\\n", "baz\n"], ["\n"], ["qux\n"]]
p e.map {|ll| ll[0...-1].map {|l| l.sub(/\\\n\z/, "") }.join + ll.last }
#=>["foo\n", "barbaz\n", "\n", "qux\n"]

Enumerable
#map のようなメソッドを使うこともできます。

@see Enumerable#chunk, Enumerable#slice_before...

Enumerable#slice_before {|elt| bool } -> Enumerator (2.0)

パターンがマッチした要素、もしくはブロックが真を返した要素から 次にマッチする手前までを チャンク化(グループ化)したものを繰り返す Enumerator を 返します。

...の手前で分割していきます。
最初の要素の評価は無視されます。

各チャンクは配列として表現されます。

Enumerable
#map のようなメソッドを使うこともできます。

# 偶数要素をチャンクの先頭と見なす
[0,2,4,1,2,4,5,3,1,4,2...
...h[:emp] = line == "\n"
prevemp && line.start_with?("From ")
}.each {|mail|
mail.pop if mail.last == "\n"
pp mail
}
}

@param initial_state 状態を保持するオブジェクト。この引数は deprecated です。

@see Enumerable#chunk, Enumerable#slice_after...

Enumerable#slice_before(initial_state) {|elt, state| bool } -> Enumerator (2.0)

パターンがマッチした要素、もしくはブロックが真を返した要素から 次にマッチする手前までを チャンク化(グループ化)したものを繰り返す Enumerator を 返します。

...の手前で分割していきます。
最初の要素の評価は無視されます。

各チャンクは配列として表現されます。

Enumerable
#map のようなメソッドを使うこともできます。

# 偶数要素をチャンクの先頭と見なす
[0,2,4,1,2,4,5,3,1,4,2...
...h[:emp] = line == "\n"
prevemp && line.start_with?("From ")
}.each {|mail|
mail.pop if mail.last == "\n"
pp mail
}
}

@param initial_state 状態を保持するオブジェクト。この引数は deprecated です。

@see Enumerable#chunk, Enumerable#slice_after...

Enumerable#slice_before(pattern) -> Enumerator (2.0)

パターンがマッチした要素、もしくはブロックが真を返した要素から 次にマッチする手前までを チャンク化(グループ化)したものを繰り返す Enumerator を 返します。

...の手前で分割していきます。
最初の要素の評価は無視されます。

各チャンクは配列として表現されます。

Enumerable
#map のようなメソッドを使うこともできます。

# 偶数要素をチャンクの先頭と見なす
[0,2,4,1,2,4,5,3,1,4,2...
...h[:emp] = line == "\n"
prevemp && line.start_with?("From ")
}.each {|mail|
mail.pop if mail.last == "\n"
pp mail
}
}

@param initial_state 状態を保持するオブジェクト。この引数は deprecated です。

@see Enumerable#chunk, Enumerable#slice_after...

Enumerable#slice_when {|elt_before, elt_after| bool } -> Enumerator (2.0)

要素を前から順にブロックで評価し、その結果によって要素をチャンクに分け た(グループ化した)要素を持つEnumerator を返します。

...び出します。
//emlist{
enum.slice_when { |elt_before, elt_after| bool }.each { |ary| ... }
//}
to_a や map などのその他の Enumerable モジュールのメソッ
ドも有用です。

例:

# 1ずつ増加する部分配列ごとに分ける。
a = [1,2,4,9,10,11,...
...# (Enumerable#chunk を使って実現する事も可能)
a = [7, 5, 9, 2, 0, 7, 9, 4, 2, 0]
p a.slice_when {|i, j| i.even? != j.even? }.to_a
# => [[7, 5, 9], [2, 0], [7, 9], [4, 2, 0]]

# 段落(空行が後ろに続く非空行の文字列)ごとに分ける。
# (Enumerable#chunk で...
...空行を無視して実現する事も可能)
lines = ["foo\n", "bar\n", "\n", "baz\n", "qux\n"]
p lines.slice_when {|l1, l2| /\A\s*\z/ =~ l1 && /\S/ =~ l2 }.to_a
# => [["foo\n", "bar\n", "\n"], ["baz\n", "qux\n"]]

@see Enumerable#chunk...

絞り込み条件を変える

Enumerable#sort -> [object] (2.0)

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

...たときは例外 TypeError が発生します。

Enumerable
#sort は安定ではありません (unstable sort)。
安定なソートが必要な場合は Enumerable#sort_by を使って工夫する必要があります。
詳しくは Enumerable#sort_by の項目を参照してください。...
...※ 比較結果が同じ要素は元の順序通りに並ぶソートを
「安定なソート (stable sort)」と言います。

@see Enumerable#sort_by...

Enumerable#sort {|a, b| ... } -> [object] (2.0)

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

...たときは例外 TypeError が発生します。

Enumerable
#sort は安定ではありません (unstable sort)。
安定なソートが必要な場合は Enumerable#sort_by を使って工夫する必要があります。
詳しくは Enumerable#sort_by の項目を参照してください。...
...※ 比較結果が同じ要素は元の順序通りに並ぶソートを
「安定なソート (stable sort)」と言います。

@see Enumerable#sort_by...

Enumerable#sort_by -> Enumerator (2.0)

ブロックの評価結果を <=> メソッドで比較することで、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 を使...
...}

$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 を以下のように使うと安定なソートを実装でき...
...果が同じ要素は元の順序通りに並ぶソートを
「安定なソート (stable sort)」と言います。

ブロックを省略した場合は、各要素をブロックで評価した値でソートした
配列を返すような Enumerator を返します。


@see Enumerable#sort...

Enumerable#sort_by {|item| ... } -> [object] (2.0)

ブロックの評価結果を <=> メソッドで比較することで、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 を使...
...}

$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 を以下のように使うと安定なソートを実装でき...
...果が同じ要素は元の順序通りに並ぶソートを
「安定なソート (stable sort)」と言います。

ブロックを省略した場合は、各要素をブロックで評価した値でソートした
配列を返すような Enumerator を返します。


@see Enumerable#sort...

Enumerable#take(n) -> Array (2.0)

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

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

@param n 要素数を指定します。

a = [1, 2, 3, 4, 5, 0]
a.take(3) # => [1, 2, 3]...

絞り込み条件を変える

<< 1 2 > >>