繰り返しを行なうクラスのための Mix-in。このモジュールの
メソッドは全て each を用いて定義されているので、インクルード
するクラスには each が定義されていなければなりません。
| 定義 |
説明 |
all? -> bool
all? {|item| ... } -> bool
|
すべての要素が真である場合に true を返します。
偽である要素があれば、ただちに false を返します。
|
any? -> bool
any? {|item| ... } -> bool
|
すべての要素が偽である場合に false を返します。
真である要素があれば、ただちに true を返します。
|
chunk {|elt| ... } -> Enumerator
chunk(initial_state) {|elt, state| ... } -> Enumerator
|
Creates an enumerator for each chunked elements.
The consecutive elements which have same block value are chunked.
|
collect -> Enumerator
map -> Enumerator
collect {|item| ... } -> [object]
map {|item| ... } -> [object]
|
各要素に対してブロックを評価した結果を全て含む配列を返します。
|
flat_map -> Enumerator
collect_concat -> Enumerator
flat_map {| obj | block } -> Array
collect_concat {| obj | block } -> Array
|
Returns a new array with the concatenated results of running
<em>block</em> once for every element in <i>enum</i>.
|
count -> Integer
count(item) -> Integer
count {|obj| ... } -> Integer
|
レシーバの要素数を返します。
|
cycle -> Enumerator
cycle {|obj| ... } -> object | nil
|
Enumerable オブジェクトの要素を、繰り返し無限に生成し続けます。
|
find(ifnone = nil) -> Enumerator
detect(ifnone = nil) -> Enumerator
find(ifnone = nil) {|item| ... } -> object
detect(ifnone = nil) {|item| ... } -> object
|
要素に対してブロックを評価した値が真になった最初の要素を返します。
|
drop(n) -> Array
|
Enumerable オブジェクトの先頭の n 要素を捨てて、
残りの要素を配列として返します。
|
drop_while -> Enumerator
drop_while {|element| ... } -> Array
|
ブロックを評価して最初に偽となった要素の手前の要素まで捨て、
残りの要素を配列として返します。
|
each_cons(n) -> Enumerator
each_cons(n) {|list| ... } -> nil
|
要素を重複ありで n 要素ずつに区切り、
ブロックに渡して繰り返します。
|
each_entry -> Enumerator
each_entry {|obj| block} -> self
|
Calls <i>block</i> once for each element in <i>self</i>, passing that
element as a parameter, converting multiple values from yield to an
array.
|
each_slice(n) -> Enumerator
each_slice(n) {|list| ... } -> nil
|
n 要素ずつブロックに渡して繰り返します。
|
each_with_index -> Enumerator
each_with_index {|item, index| ... } -> self
|
要素とそのインデックスをブロックに渡して繰り返します。
|
each_with_object(obj) -> Enumerator
each_with_object(obj) {|(*args), memo_obj| ... } -> 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 を返します。
|
first -> object | nil
first(n) -> Array
|
Enumerable オブジェクトの最初の要素、もしくは最初の n 要素を返します。
|
grep(pattern) -> [object]
grep(pattern) {|item| ... } -> [object]
|
pattern === item が成立する要素を全て含んだ配列を返します。
|
group_by -> Enumerator
group_by {|obj| ... } -> Hash
|
ブロックを評価した結果をキー、対応する要素の配列を値とするハッシュを返します。
|
member?(val) -> bool
include?(val) -> bool
|
val と == の関係にある要素を含むとき真を返します。
|
inject(init = self.first) {|result, item| ... } -> object
inject(sym) -> object
inject(init, sym) -> object
reduce(init = self.first) {|result, item| ... } -> object
reduce(sym) -> object
reduce(init, sym) -> object
|
リストのたたみこみ演算を行います。
|
max -> object
|
最大の要素を返します。
全要素が互いに <=> メソッドで比較できることを仮定しています。
|
max {|a, b| ... } -> object
|
ブロックの評価結果で各要素の大小判定を行い、最大の要素を返します。
要素が存在しなければ nil を返します。
|
max_by -> Enumerator
max_by {|item| ... } -> object
|
各要素を順番にブロックに渡して実行し、
その評価結果を <=> で比較して、
最大であった値に対応する元の要素を返します。
|
min -> object
|
最小の要素を返します。
全要素が互いに <=> メソッドで比較できることを仮定しています。
|
min {|a, b| ... } -> object
|
ブロックの評価結果で各要素の大小判定を行い、最小の要素を返します。
要素が存在しなければ nil を返します。
|
min_by -> Enumerator
min_by {|item| ... } -> object
|
各要素を順番にブロックに渡して評価し、
その評価結果を <=> で比較して、
最大であった値に対応する元の要素を返します。
|
minmax -> [object, object]
minmax {|a, b| ... } -> [object, object]
|
Enumerable オブジェクトの各要素のうち最小の要素と最大の要素を
要素とするサイズ 2 の配列を返します。
|
minmax_by -> Enumerator
minmax_by {|obj| ... } -> [object, object]
|
Enumerable オブジェクトの各要素をブロックに渡して評価し、その結果を <=> で比較して
最小の要素と最大の要素を要素とするサイズ 2 の配列を返します。
|
none? -> bool
none? {|obj| ... } -> bool
|
ブロックを指定しない場合は、 Enumerable オブジェクトのすべての
要素が偽であれば真を返します。そうでなければ偽を返します。
|
one? -> bool
one? {|obj| ... } -> bool
|
ブロックを指定しない場合は、 Enumerable オブジェクトの要素のうち
ちょうど一つだけが真であれば、真を返します。
そうでなければ偽を返します。
|
partition -> Enumerator
partition {|item| ... } -> [[object], [object]]
|
各要素を、ブロックの条件を満たす要素と満たさない要素に分割します。
各要素に対してブロックを評価して、その値が真であった要素の配列と、
偽であった要素の配列の 2 つを配列に入れて返します。
|
reject -> Enumerator
reject {|item| ... } -> [object]
|
各要素に対してブロックを評価し、
その値が偽であった要素を集めた新しい配列を返します。
条件を反転させた select です。
|
reverse_each -> Enumerator
reverse_each {|element| ... } -> self
|
逆順に各要素に対してブロックを評価します。
|
slice_before(pattern) -> Enumerator
slice_before {|elt| bool } -> Enumerator
slice_before(initial_state) {|elt, state| bool } -> Enumerator
|
Creates an enumerator for each chunked elements.
|
sort -> [object]
sort {|a, b| ... } -> [object]
|
全ての要素を昇順にソートした配列を生成して返します。
|
sort_by -> Enumerator
sort_by {|item| ... } -> [object]
|
ブロックの評価結果を <=> メソッドで比較することで、self を昇
順にソートします。ソートされた配列を新たに生成して返します。
つまり、以下とほぼ同じ動作をします。
|
take(n) -> Array
|
Enumerable オブジェクトの先頭から n 要素を配列として返します。
|
take_while -> Enumerator
take_while {|element| ... } -> Array
|
Enumerable オブジェクトの要素を順に偽になるまでブロックで評価します。
最初に偽になった要素の手前の要素までを配列として返します。
|
zip(*lists) -> [[object]]
zip(*lists) {|v1, v2, ...| ...} -> nil
|
self と引数に渡した配列の各要素からなる配列の配列を生成して返します。
生成される配列の要素数は self の要素数と同じです。
|
