種類:インスタンスメソッド > クエリ:l > バージョン:2.4.0 > クエリ:numerator

154件ヒット [1-100件を表示] （0.159秒）

トップページ >

:インスタンスメソッド

:2.4.0

:numerator

別のキーワード

ライブラリ

ビルトイン (129)
date (1)
matrix (9)
pathname (2)
prime (1)
rexml/document (4)
stringio (3)
tsort (2)
zlib (3)

クラス

ARGF.class (13)
Array (12)
Complex (2)
Date (1)
Enumerator (6)
Enumerator::Lazy (33)
Enumerator::Yielder (2)
Float (2)
Hash (7)
IO (9)
Matrix (6)
Numeric (3)
Pathname (2)
Prime (1)
REXML::Parent (4)
Rational (2)
String (2)
StringIO (3)
Struct (1)
Vector (3)
Zlib::GzipReader (3)

モジュール

Enumerable (35)
TSort (2)

キーワード

<< (1)
bytes (1)
chars (1)
chunk (3)
chunk_while (2)
codepoints (1)
collect (5)
collect! (1)
collect2 (1)
collect_concat (2)
cycle (2)
delete_if (3)
denominator (3)
detect (1)
drop (1)
drop_while (3)
each (11)
each_byte (2)
each_char (2)
each_child (2)
each_codepoint (1)
each_cons (1)
each_entry (1)
each_index (1)
each_line (9)
each_slice (1)
each_strongly_connected_component (1)
each_strongly_connected_component_from (1)
each_value (1)
each_with_index (2)
each_with_object (1)
enum_for (2)
feed (1)
find (1)
find_all (2)
find_index (2)
flat_map (2)
force (1)
grep (1)
grep_v (1)
group_by (1)
index (1)
lazy (2)
lines (7)
map (5)
map! (1)
max_by (2)
min_by (2)
minmax_by (1)
next_values (1)
partition (1)
peek_values (1)
permutation (1)
reject (2)
reject! (2)
reverse_each (1)
rewind (1)
select (5)
select! (2)
size (1)
slice_after (4)
slice_before (5)
slice_when (2)
sort_by (1)
step (4)
take (1)
take_while (4)
to_enum (2)
transform_values (1)
transform_values! (1)
uniq (2)
yield (1)
zip (2)

検索結果

<< 1 2 > >>

Complex#numerator -> Complex (63643.0)

2.4.0

インスタンスメソッド

分子を返します。

分子を返します。

//emlist[例][ruby]{
Complex('1/2+2/3i').numerator # => (3+4i)
Complex(3).numerator # => (3+0i)
//}

@see Complex#denominator

Rational#numerator -> Integer (63379.0)

2.4.0

インスタンスメソッド

分子を返します。

分子を返します。

@return 分子を返します。

//emlist[例][ruby]{
Rational(7).numerator # => 7
Rational(7, 1).numerator # => 7
Rational(9, -4).numerator # => -9
Rational(-2, -10).numerator # => 1
//}

@see Rational#denominator

Float#numerator -> Integer (63343.0)

2.4.0

インスタンスメソッド

自身を Rational に変換した時の分子を返します。

自身を Rational に変換した時の分子を返します。

@return 分子を返します。

//emlist[例][ruby]{
2.0.numerator # => 2
0.5.numerator # => 1
//}

@see Float#denominator

Enumerator::Lazy#lazy -> self (36304.0)

2.4.0

インスタンスメソッド

self を返します。

self を返します。

//emlist[例][ruby]{
lazy = (100..Float::INFINITY).lazy
p lazy.lazy # => #<Enumerator::Lazy: 100..Infinity>
p lazy == lazy.lazy # => true
//}

Enumerator::Yielder#yield(*object) -> () (36304.0)

2.4.0

インスタンスメソッド

Enumerator.new で使うメソッドです。

Enumerator.new で使うメソッドです。

生成された Enumerator オブジェクトの each メソッドを呼ぶと
Enumerator::Yielder オブジェクトが渡されたブロックが実行され、
ブロック内の yield メソッドが呼ばれるたびに each に渡された
ブロックが yield メソッドに渡された値とともに繰り返されます。

//emlist[例][ruby]{
enum = Enumerator.new do |y|
y.yield 1, 2, 3
end

enum.each do |x, y, z|
p [x, y, z]
end
# => [...

絞り込み条件を変える

Enumerator::Lazy#flat_map {|item| ... } -> Enumerator::Lazy (27904.0)

2.4.0

インスタンスメソッド

ブロックの実行結果をひとつに繋げたものに対してイテレートするような Enumerator::Lazy のインスタンスを返します。

ブロックの実行結果をひとつに繋げたものに対してイテレートするような
Enumerator::Lazy のインスタンスを返します。

//emlist[][ruby]{
["foo", "bar"].lazy.flat_map {|i| i.each_char.lazy}.force
#=> ["f", "o", "o", "b", "a", "r"]
//}

ブロックの返した値 x は、以下の場合にのみ分解され、連結されます。

* x が配列であるか、to_ary メソッドを持つとき
* x が each および force メソッドを持つ (例：Enumerator::Lazy) ...

Enumerable#chunk_while {|elt_before, elt_after| ... } -> Enumerator (27604.0)

2.4.0

インスタンスメソッド

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

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

隣り合う値をブロックパラメータ elt_before、elt_after に渡し、ブロックの
評価値が偽になる所でチャンクを区切ります。

ブロックは self の長さ - 1 回呼び出されます。

@return チャンクごとの配列をブロックパラメータに渡す Enumerator
を返します。eachメソッドは以下のように呼び出します。
//emlist{
enum.chunk_while { |elt_before, elt_af...

Enumerable#collect -> Enumerator (27604.0)

2.4.0

インスタンスメソッド

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

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

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

//emlist[例][ruby]{
# すべて 3 倍にした配列を返す
p (1..3).map {|n| n * 3 } # => [3, 6, 9]
p (1..3).collect { "cat" } # => ["cat", "cat", "cat"]
//}

@see Array#collect, Array#map

Enumerable#collect_concat -> Enumerator (27604.0)

2.4.0

インスタンスメソッド

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

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

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

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

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

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

2.4.0

インスタンスメソッド

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

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

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

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

絞り込み条件を変える

Enumerable#drop_while -> Enumerator (27604.0)

2.4.0

インスタンスメソッド

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

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

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

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

Enumerable#flat_map -> Enumerator (27604.0)

2.4.0

インスタンスメソッド

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

Enumerable#take_while -> Enumerator (27604.0)

2.4.0

インスタンスメソッド

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

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

//emlist[例][ruby]{
e = [1, 2, 3, 4, 5, 0].each
e.take_while {|i| i < 3 } # => [1, 2]
//}

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

@see Array#take_while

Enumerator::Lazy#chunk_while {|elt_before, elt_after| ... } -> Enumerator::Lazy (27604.0)

2.4.0

インスタンスメソッド

Enumerable#chunk_while と同じですが、Enumerator ではなく Enumerator::Lazy を返します。

Enumerable#chunk_while と同じですが、Enumerator ではなく Enumerator::Lazy を返します。

@raise ArgumentError ブロックを指定しなかった場合に発生します。

Enumerator::Lazy#collect {|item| ... } -> Enumerator::Lazy (27604.0)

2.4.0

インスタンスメソッド

Enumerable#map と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#map と同じですが、配列ではなくEnumerator::Lazy を返します。

@raise ArgumentError ブロックを指定しなかった場合に発生します。

//emlist[例][ruby]{
1.step.lazy.map{ |n| n % 3 == 0 }
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:map>

1.step.lazy.collect{ |n| n.succ }.take(10).force
# => [2, 3, 4, 5, 6, 7, 8,...

絞り込み条件を変える

Enumerator::Lazy#collect_concat {|item| ... } -> Enumerator::Lazy (27604.0)

2.4.0

インスタンスメソッド

ブロックの実行結果をひとつに繋げたものに対してイテレートするような Enumerator::Lazy のインスタンスを返します。

Enumerator::Lazy#drop_while {|item| ... } -> Enumerator::Lazy (27604.0)

2.4.0

インスタンスメソッド

Enumerable#drop_while と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#drop_while と同じですが、配列ではなくEnumerator::Lazy を返します。

//emlist[例][ruby]{
1.step.lazy.drop_while { |i| i < 42 }
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:drop_while>

1.step.lazy.drop_while { |i| i < 42 }.take(10).force
# => [42, 43, 44, 45, 46, 47, 48, 49, 50, 51]
//...

Enumerator::Lazy#find_all {|item| ... } -> Enumerator::Lazy (27604.0)

2.4.0

インスタンスメソッド

Enumerable#select と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#select と同じですが、配列ではなくEnumerator::Lazy を返します。

@raise ArgumentError ブロックを指定しなかった場合に発生します。

//emlist[例][ruby]{
1.step.lazy.find_all { |i| i.even? }
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:find_all>

1.step.lazy.select { |i| i.even? }.take(10).force
# => [2, 4, 6,...

Enumerator::Lazy#select {|item| ... } -> Enumerator::Lazy (27604.0)

2.4.0

インスタンスメソッド

Enumerable#select と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerator::Lazy#slice_after {|elt| bool } -> Enumerator::Lazy (27604.0)

2.4.0

インスタンスメソッド

Enumerable#slice_after と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerable#slice_after と同じですが、配列ではなく Enumerator::Lazy を返します。

//emlist[例][ruby]{
1.step.lazy.slice_after { |e| e % 3 == 0 }
# => #<Enumerator::Lazy: #<Enumerator: #<Enumerator::Generator:0x007fd73980e6f8>:each>>

1.step.lazy.slice_after { |e| e % 3 == 0 }.take(5).force
# => [[1, 2, 3], [4, 5, 6], [...

絞り込み条件を変える

Enumerator::Lazy#slice_after(pattern) -> Enumerator::Lazy (27604.0)

2.4.0

インスタンスメソッド

Enumerable#slice_after と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerator::Lazy#slice_before {|elt| bool } -> Enumerator::Lazy (27604.0)

2.4.0

インスタンスメソッド

Enumerable#slice_before と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerable#slice_before と同じですが、配列ではなく Enumerator::Lazy を返します。

//emlist[例][ruby]{
1.step.lazy.slice_before { |e| e.even? }
# => #<Enumerator::Lazy: #<Enumerator: #<Enumerator::Generator:0x00007f9f31844ce8>:each>>

1.step.lazy.slice_before { |e| e % 3 == 0 }.take(5).force
# => [[1, 2], [3, 4, 5], [6...

Enumerator::Lazy#slice_before(initial_state) {|elt, state| bool } -> Enumerator::Lazy (27604.0)

2.4.0

インスタンスメソッド

Enumerable#slice_before と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerator::Lazy#slice_before(pattern) -> Enumerator::Lazy (27604.0)

2.4.0

インスタンスメソッド

Enumerable#slice_before と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerator::Lazy#slice_when {|elt_before, elt_after| bool } -> Enumerator::Lazy (27604.0)

2.4.0

インスタンスメソッド

Enumerable#slice_when と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerable#slice_when と同じですが、配列ではなく Enumerator::Lazy を返します。

//emlist[例][ruby]{
1.step.lazy.slice_when { |i, j| (i + j) % 5 == 0 }
# => #<Enumerator::Lazy: #<Enumerator: #<Enumerator::Generator:0x00007fce84118348>:each>>

1.step.lazy.slice_when { |i, j| (i + j) % 5 == 0 }.take(5).force
# => [[1, 2]...

絞り込み条件を変える

Enumerator::Lazy#take_while -> Enumerator::Lazy (27604.0)

2.4.0

インスタンスメソッド

Enumerable#take_while と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#take_while と同じですが、配列ではなくEnumerator::Lazy を返します。

//emlist[例][ruby]{
1.step.lazy.zip(('a'..'z').cycle).take_while { |e| e.first < 100_000 }
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:zip(#<Enumerator: "a".."z":cycle>)>:take_while>

1.step.lazy....

Enumerator::Lazy#take_while {|item| ... } -> Enumerator::Lazy (27604.0)

2.4.0

インスタンスメソッド

Enumerable#take_while と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerator#next_values -> Array (27304.0)

2.4.0

インスタンスメソッド

「次」のオブジェクトを配列で返します。

「次」のオブジェクトを配列で返します。

Enumerator#next とほぼ同様の挙動をします。終端まで到達した場合は
StopIteration 例外を発生させます。

このメソッドは、
yield
と
yield nil
を区別するために使えます。

next メソッドによる外部列挙の状態は他のイテレータメソッドによる
内部列挙には影響を与えません。
ただし、 IO#each_line のようにおおもとの列挙メカニズムが副作用を
伴っている場合には影響があり得ます。

//emlist[例: next と next_values の違いを][ruby]{
o = Object...

Enumerator#peek_values -> Array (27304.0)

2.4.0

インスタンスメソッド

Enumerator#next_values のように「次」のオブジェクトを配列で返しますが、列挙状態を変化させません。

Enumerator#next_values のように「次」のオブジェクトを
配列で返しますが、列挙状態を変化させません。

Enumerator#next, Enumerator#next_values のように
現在までの列挙状態に応じて「次」のオブジェクトを返しますが、
next と異なり列挙状態を変更しません。

列挙が既に最後へ到達している場合は、StopIteration 例外を発生します。

このメソッドは Enumerator#next_values と同様
yield
と
yield nil
を区別するために使えます。

//emlist[例][ruby]{
o =...

ARGF.class#each_line(rs = $/, limit) -> Enumerator (18904.0)

2.4.0

インスタンスメソッド

ARGFの現在位置から 1 行ずつ文字列として読み込み、それを引数として与えられたブロックを実行します。

ARGFの現在位置から 1 行ずつ文字列として読み込み、それを引数として与えら
れたブロックを実行します。

ブロックが与えられなかった場合は、Enumerator オブジェクトを生成し
て返します。

このメソッドはスクリプトに指定した引数(Object::ARGV を参照) をファ
イル名とみなして、それらのファイルを連結した 1 つの仮想ファイルを表すオ
ブジェクトです。そのため、最初のファイルを最後まで読んだ後は次のファイ
ルの内容を返します。現在の行についてファイル名や行数を得るには
ARGF.class#filename と ARGF.class#lineno を使用します。

...

絞り込み条件を変える

ARGF.class#lines(limit) -> Enumerator (18904.0)

2.4.0

インスタンスメソッド

このメソッドは obsolete です。代わりに ARGF.class#each_line を使用してください。使用すると警告メッセージが表示されます。

このメソッドは obsolete です。
代わりに ARGF.class#each_line を使用してください。
使用すると警告メッセージが表示されます。

@see $/, ARGF.class#each_line

ARGF.class#lines(rs, limit) -> Enumerator (18904.0)

2.4.0

インスタンスメソッド

このメソッドは obsolete です。代わりに ARGF.class#each_line を使用してください。使用すると警告メッセージが表示されます。

このメソッドは obsolete です。
代わりに ARGF.class#each_line を使用してください。
使用すると警告メッセージが表示されます。

@see $/, ARGF.class#each_line

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

2.4.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...

IO#lines(limit) -> Enumerator (18904.0)

2.4.0

インスタンスメソッド

このメソッドは obsolete です。代わりに IO#each_line を使用してください。

このメソッドは obsolete です。
代わりに IO#each_line を使用してください。

使用すると警告メッセージが表示されます。

IO の現在位置から 1 行ずつ文字列として読み込み、それを引数として
与えられたブロックを実行します。

ブロックが与えられなかった場合は、自身から生成した
Enumerator オブジェクトを返します。

テキスト読み込みメソッドとして動作します。

limit で最大読み込みバイト数を指定します。ただしマルチバイト文字が途中で
切れないように余分に読み込む場合があります。

@param rs 行の区切りを文字列で指定します。rs に ni...

IO#lines(rs, limit) -> Enumerator (18904.0)

2.4.0

インスタンスメソッド

このメソッドは obsolete です。代わりに IO#each_line を使用してください。

絞り込み条件を変える

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

2.4.0

インスタンスメソッド

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

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

隣り合う値をブロックパラメータ elt_before、elt_after に渡し、ブロックの
評価値が真になる所でチャンクを区切ります。

ブロックは self の長さ - 1 回呼び出されます。

@return チャンクごとの配列をブロックパラメータに渡す Enumerator
を返します。eachメソッドは以下のように呼び出します。
//emlist{
enum.slice_when { |elt_before, elt_aft...

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

2.4.0

インスタンスメソッド

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

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

パターンを渡した場合は各要素に対し === が呼び出され、それが真になった
ところをチャンクの末尾と見なします。ブロックを渡した場合は、各要素に対
しブロックを適用し返り値が真であった要素をチャンクの末尾と見なします。

パターンもブロックも最初から最後の要素まで呼び出されます。

各チャンクは配列として表現されます。そのため、以下のような呼び出しを行
う事もできます。

//emlist[例][ruby]{
enum.sl...

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

2.4.0

インスタンスメソッド

Struct#select -> Enumerator (18640.0)

2.4.0

インスタンスメソッド

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

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

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

//emlist[例][ruby]{
Lots = Struct.new(:a, :b, :c, :d, :e, :f)
l = Lots.new(11, 22, 33, 44, 55, 66)
l.select {|v| (v % 2).zero? } #=> [22, 44, 66]
//}

[注意] 本メソッドの記述は Struct の下位クラスのインスタンスに対して...

ARGF.class#each_line(rs = $/) -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

ARGFの現在位置から 1 行ずつ文字列として読み込み、それを引数として与えられたブロックを実行します。

絞り込み条件を変える

ARGF.class#lines(rs = $/) -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

このメソッドは obsolete です。代わりに ARGF.class#each_line を使用してください。使用すると警告メッセージが表示されます。

このメソッドは obsolete です。
代わりに ARGF.class#each_line を使用してください。
使用すると警告メッセージが表示されます。

@see $/, ARGF.class#each_line

Array#collect -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

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

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

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

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

@see Enumerable#collect, Enumerable#map

Array#collect! -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

各要素を順番にブロックに渡して評価し、その結果で要素を置き換えます。

各要素を順番にブロックに渡して評価し、その結果で要素を
置き換えます。

ブロックが与えられなかった場合は、自身と map! から生成した
Enumerator オブジェクトを返します。

//emlist[例][ruby]{
ary = [1, 2, 3]
ary.map! {|i| i * 3 }
p ary #=> [3, 6, 9]

ary = [1, 2, 3]
e = ary.map!
e.each{ 1 }
p ary #=> [1, 1, 1]
//}

@see Array#collect, Enumerator

Array#cycle(n=nil) -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

配列の全要素を n 回(nilの場合は無限に)繰り返しブロックを呼びだします。

配列の全要素を n 回(nilの場合は無限に)繰り返しブロックを呼びだします。

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

@param n 繰り返したい回数を整数で指定します。
整数以外のオブジェクトを指定した場合は to_int メソッドによる暗
黙の型変換を試みます。

@raise TypeError 引数に整数以外の(暗黙の型変換が行えない)オブジェクトを
指定した場合に発生します。

//emlist[例][ruby]{
a = ["a", "b", "c"]
a.cycle {|x| p...

Array#delete_if -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

要素を順番にブロックに渡して評価し、その結果が真になった要素をすべて削除します。 delete_if は常に self を返しますが、reject! は要素が 1 つ以上削除されれば self を、 1 つも削除されなければ nil を返します。

要素を順番にブロックに渡して評価し、その結果が真になった要素をすべて削除します。
delete_if は常に self を返しますが、reject! は要素が 1 つ以上削除されれば self を、
1 つも削除されなければ nil を返します。

ブロックが与えられなかった場合は、自身と reject! から生成した
Enumerator オブジェクトを返します。
返された Enumerator オブジェクトの each メソッドには、
もとの配列に対して副作用があることに注意してください。

//emlist[例][ruby]{
a = [0, 1, 2, 3, 4, 5]
a.dele...

絞り込み条件を変える

Array#drop_while -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

ブロックを評価して最初に偽となった要素の手前の要素まで捨て、残りの要素を配列として返します。このメソッドは自身を破壊的に変更しません。

ブロックを評価して最初に偽となった要素の手前の要素まで捨て、
残りの要素を配列として返します。
このメソッドは自身を破壊的に変更しません。

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

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

# 変数aの値は変化しない
a # => [1, 2, 3, 4, 5, 0]
//}

@see Enumerable#drop_while, Array...

Array#select -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

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

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

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

//emlist[例][ruby]{
[1,2,3,4,5].select # => #<Enumerator: [1, 2, 3, 4, 5]:select>
[1,2,3,4,5].select { |num| num.even? } # => [2, 4]
//}
@see Enumerable#select
@see Array#select...

Array#select! -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

ブロックが真を返した要素を残し、偽を返した要素を自身から削除します。変更があった場合は self を、変更がなかった場合には nil を返します。

ブロックが真を返した要素を残し、偽を返した要素を自身から削除します。
変更があった場合は self を、
変更がなかった場合には nil を返します。

//emlist[例][ruby]{
a = %w{ a b c d e f }
a.select! {|v| v =~ /[a-z]/ } # => nil
a # => ["a", "b", "c", "d", "e", "f"]
//}

ブロックが与えられなかった場合は、自身と select! から生成した
Enumerator オブジェクトを返します。

@see Array#keep_if, Array#reject!

Array#take_while -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

配列の要素を順に偽になるまでブロックで評価します。最初に偽になった要素の手前の要素までを配列として返します。このメソッドは自身を破壊的に変更しません。

配列の要素を順に偽になるまでブロックで評価します。
最初に偽になった要素の手前の要素までを配列として返します。
このメソッドは自身を破壊的に変更しません。

//emlist[例][ruby]{
a = [1, 2, 3, 4, 5, 0]
a.take_while {|i| i < 3 } # => [1, 2]
//}

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

@see Enumerable#take_while

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

2.4.0

インスタンスメソッド

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

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

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

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

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

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

@see Enumerable#each_cons

絞り込み条件を変える

Enumerable#find_all -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

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

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

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

//emlist[例][ruby]{
(1..10).find_all # => #<Enumerator: 1..10:find_all>
(1..10).find_all { |i| i % 3 == 0 } # => [3, 6, 9]

[1,2,3,4,5].select # => #<E...

Enumerable#select -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

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

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

2.4.0

インスタンスメソッド

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

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

パターンを渡した場合は各要素に対し === が呼び出され、
それが真になったところをチャンクの先頭と見なします。
ブロックを渡した場合は、各要素に対しブロックを適用し
返り値が真であった要素をチャンクの先頭と見なします。

より厳密にいうと、「先頭要素」の手前で分割していきます。
最初の要素の評価は無視されます。

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

Enumerable#to_a や Enumerable#map ...

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

2.4.0

インスタンスメソッド

Enumerator::Lazy#chunk {|elt| ... } -> Enumerator::Lazy (18604.0)

2.4.0

インスタンスメソッド

Enumerable#chunk と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerable#chunk と同じですが、配列ではなく Enumerator::Lazy を返します。

//emlist[例][ruby]{
1.step.lazy.chunk{ |n| n % 3 == 0 }
# => #<Enumerator::Lazy: #<Enumerator: #<Enumerator::Generator:0x007f8bf18118f0>:each>>

1.step.lazy.chunk{ |n| n % 3 == 0 }.take(5).force
# => [[false, [1, 2]], [true, [3]], [false, [4, 5...

絞り込み条件を変える

Enumerator::Lazy#chunk(initial_state) {|elt, state| ... } -> Enumerator::Lazy (18604.0)

2.4.0

インスタンスメソッド

Enumerable#chunk と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerator::Lazy#drop(n) -> Enumerator::Lazy (18604.0)

2.4.0

インスタンスメソッド

Enumerable#drop と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#drop と同じですが、配列ではなくEnumerator::Lazy を返します。

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

@raise ArgumentError n に負の数を指定した場合に発生します。

//emlist[例][ruby]{
1.step.lazy.drop(3)
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:drop(3)>

1.step.lazy.drop(3).take(10).force
# => [4, 5, 6, 7, 8, 9, 10, 1...

Enumerator::Lazy#enum_for(method = :each, *args) -> Enumerator::Lazy (18604.0)

2.4.0

インスタンスメソッド

Object#to_enum と同じですが、Enumerator::Lazy を返します。

Object#to_enum と同じですが、Enumerator::Lazy を返します。

to_enum は「ブロック付きで呼ぶとループを実行し、ブロックを省略した場合は
Enumerator を返す」ようなメソッドを定義するときによく使われます。
このときに lazy 性が正しく引き継がれるように、Lazy#to_enum は
素のEnumerator ではなく Enumerator::Lazy を返すようになっています。

//emlist[例][ruby]{
module Enumerable
# 要素をn回ずつ繰り返すメソッド
# 例：[1,2,3].repeat(2) ...

Enumerator::Lazy#enum_for(method = :each, *args) {|*args| block} -> Enumerator::Lazy (18604.0)

2.4.0

インスタンスメソッド

Object#to_enum と同じですが、Enumerator::Lazy を返します。

Enumerator::Lazy#grep(pattern) {|item| ... } -> Enumerator::Lazy (18604.0)

2.4.0

インスタンスメソッド

Enumerable#grep と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#grep と同じですが、配列ではなくEnumerator::Lazy を返します。

//emlist[例][ruby]{
(100..Float::INFINITY).lazy.map(&:to_s).grep(/\A(\d)\1+\z/)
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: 100..Infinity>:map>:grep(/\A(\d)\1+\z/)>
(100..Float::INFINITY).lazy.map(&:to_s).grep(/\A(\d)\1+\z/)....

絞り込み条件を変える

Enumerator::Lazy#grep_v(pattern) {|item| ... } -> Enumerator::Lazy (18604.0)

2.4.0

インスタンスメソッド

Enumerable#grep_v と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#grep_v と同じですが、配列ではなくEnumerator::Lazy を返します。

//emlist[例][ruby]{
(100..Float::INFINITY).lazy.map(&:to_s).grep_v(/(\d).*\1/)
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: 100..Infinity>:map>:grep_v(/(\d).*\1/)>
(100..Float::INFINITY).lazy.map(&:to_s).grep_v(/(\d).*\1/).t...

Enumerator::Lazy#map {|item| ... } -> Enumerator::Lazy (18604.0)

2.4.0

インスタンスメソッド

Enumerable#map と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerator::Lazy#reject {|item| ... } -> Enumerator::Lazy (18604.0)

2.4.0

インスタンスメソッド

Enumerable#reject と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#reject と同じですが、配列ではなくEnumerator::Lazy を返します。

@raise ArgumentError ブロックを指定しなかった場合に発生します。

//emlist[例][ruby]{
1.step.lazy.reject { |i| i.even? }
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:reject>

1.step.lazy.reject { |i| i.even? }.take(10).force
# => [1, 3, 5, 7, ...

Enumerator::Lazy#take(n) -> Enumerator::Lazy (18604.0)

2.4.0

インスタンスメソッド

Enumerable#take と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#take と同じですが、配列ではなくEnumerator::Lazy を返します。

n が大きな数 (100000とか) の場合に備えて再定義されています。
配列が必要な場合は Enumerable#first を使って下さい。

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

@raise ArgumentError n に負の数を指定した場合に発生します。

//emlist[例][ruby]{
1.step.lazy.take(5)
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:...

Enumerator::Lazy#to_enum(method = :each, *args) -> Enumerator::Lazy (18604.0)

2.4.0

インスタンスメソッド

Object#to_enum と同じですが、Enumerator::Lazy を返します。

絞り込み条件を変える

Enumerator::Lazy#to_enum(method = :each, *args) {|*args| block} -> Enumerator::Lazy (18604.0)

2.4.0

インスタンスメソッド

Object#to_enum と同じですが、Enumerator::Lazy を返します。

Enumerator::Lazy#uniq -> Enumerator::Lazy (18604.0)

2.4.0

インスタンスメソッド

Enumerable#uniq と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerator::Lazy#uniq {|item| ... } -> Enumerator::Lazy (18604.0)

2.4.0

インスタンスメソッド

Enumerable#uniq と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerator::Lazy#zip(*lists) -> Enumerator::Lazy (18604.0)

2.4.0

インスタンスメソッド

Enumerable#zip と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#zip と同じですが、配列ではなくEnumerator::Lazy を返します。

ただし一貫性のため、ブロック付きで呼び出した場合は Enumerable#zip と
同じ挙動になります。

//emlist[例][ruby]{
1.step.lazy.zip(('a'..'z').cycle)
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:zip(#<Enumerator: "a".."z":cycle>)>

1.step.lazy.zip(('a'..'z').cycle)...

Hash#delete_if -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

キーと値を引数としてブロックを評価した結果が真であるような要素を self から削除します。

キーと値を引数としてブロックを評価した結果が真であ
るような要素を self から削除します。

delete_if は常に self を返します。
reject! は、要素を削除しなかった場合には nil を返し、
そうでなければ self を返します。

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

//emlist[例][ruby]{
h = { 2 => "8" ,4 => "6" ,6 => "4" ,8 => "2" }

p h.reject!{|key, value| key.to_i < value.to_i } #=> { 6 => "4", 8 =...

絞り込み条件を変える

Hash#each_value -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

ハッシュの値を引数としてブロックを評価します。

ハッシュの値を引数としてブロックを評価します。

反復の際の評価順序はキーが追加された順です。
ブロック付きの場合selfを、
無しで呼ばれた場合 Enumerator を返します。

//emlist[例][ruby]{
{:a=>1, :b=>2}.each_value {|v| p v}
#=> 1
# 2

p({:a=>1, :b=>2}.each_value) # => #<Enumerator: {:a=>1, :b=>2}:each_value>
//}

@see Hash#each_pair,Hash#each_key

Hash#select -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

key, value のペアについてブロックを評価し，真となるペアだけを含むハッシュを生成して返します。

key, value のペアについてブロックを評価し，真となるペアだけを含む
ハッシュを生成して返します。

ブロックが与えられなかった場合は、自身と select から生成した
Enumerator オブジェクトを返します。

//emlist[][ruby]{
h = { "a" => 100, "b" => 200, "c" => 300 }
h.select {|k,v| k > "a"} #=> {"b" => 200, "c" => 300}
h.select {|k,v| v < 200} #=> {"a" => 100}
//}

@see Hash#select!, ...

Hash#transform_values -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

すべての値に対してブロックを呼び出した結果で置き換えたハッシュを返します。キーは変化しません。

すべての値に対してブロックを呼び出した結果で置き換えたハッシュを返します。
キーは変化しません。

@return 置き換えたハッシュを返します。
ブロックが与えられなかった場合は、Enumerator オブジェクトを
返します。

//emlist[例][ruby]{
h = { a: 1, b: 2, c: 3 }
h.transform_values {|v| v * v + 1 } #=> { a: 2, b: 5, c: 10 }
h.transform_values(&:to_s) #=> { a: "1", b: "2", ...

Hash#transform_values! -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

すべての値に対してブロックを呼び出した結果でハッシュの値を変更します。キーは変化しません。

すべての値に対してブロックを呼び出した結果でハッシュの値を変更します。
キーは変化しません。

@return transform_values! は常に self を返します。
ブロックが与えられなかった場合は、Enumerator オブジェクトを
返します。

//emlist[例][ruby]{
h = { a: 1, b: 2, c: 3 }
h.transform_values! {|v| v * v + 1 } #=> { a: 2, b: 5, c: 10 }
h.transform_values!(&:to_s) #=> ...

IO#lines(rs = $/) -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

このメソッドは obsolete です。代わりに IO#each_line を使用してください。

絞り込み条件を変える

Matrix#collect -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

行列の各要素に対してブロックの適用を繰り返した結果を、要素として持つ行列を生成します。

行列の各要素に対してブロックの適用を繰り返した結果を、要素として持つ行列を生成します。

ブロックがない場合、 Enumerator を返します。

//emlist[例][ruby]{
require 'matrix'

m = Matrix[[1, 2], [3, 4]]
p m.map { |x| x + 100 } # => Matrix[[101, 102], [103, 104]]
//}

@see Matrix#each

Pathname#each_child(with_directory = true) -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

self.children(with_directory).each と同じです。

self.children(with_directory).each と同じです。

@param with_directory 偽を指定するとファイル名のみ返します。デフォルトは真です。

//emlist[例][ruby]{
require "pathname"

Pathname("/usr/local").each_child {|f| p f }
# => #<Pathname:/usr/local/bin>
# => #<Pathname:/usr/local/etc>
# => #<Pathname:/usr/local/include>
# => #<Pathname:/us...

Pathname#each_line(*args) -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

IO.foreach(self.to_s, *args, &block) と同じです。

IO.foreach(self.to_s, *args, &block) と同じです。

//emlist[例][ruby]{
require "pathname"

IO.write("testfile", "line1\nline2,\nline3\n")
Pathname("testfile").each_line
# => #<Enumerator: IO:foreach("testfile")>
//}

//emlist[例ブロックを指定][ruby]{
require "pathname"

IO.write("testfile", "line1\nline2,\nline3\...

REXML::Parent#delete_if -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

各子ノードに対しブロックを呼び出し、真を返したノードを削除します。

各子ノードに対しブロックを呼び出し、真を返したノードを削除します。

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

REXML::Parent#each_child -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

各子ノードに対しブロックを呼び出します。

各子ノードに対しブロックを呼び出します。

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

絞り込み条件を変える

String#each_line(rs = $/, chomp: false) -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

文字列中の各行に対して繰り返します。行の区切りは rs に指定した文字列で、そのデフォルト値は変数 $/ の値です。各 line には区切りの文字列も含みます。

文字列中の各行に対して繰り返します。
行の区切りは rs に指定した文字列で、
そのデフォルト値は変数 $/ の値です。
各 line には区切りの文字列も含みます。

rs に nil を指定すると行区切りなしとみなします。
rs に空文字列 "" を指定すると「パラグラフモード」になり、
改行コードが 2 つ以上連続するところで文字列を分割します
(つまり空行で分割します)。

@param rs 行末を示す文字列
@param chomp true を指定すると各行の末尾から rs を取り除きます。

//emlist[例][ruby]{
"aa\nbb\ncc\n".each_...

TSort#each_strongly_connected_component -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

TSort#strongly_connected_components メソッドのイテレータ版です。
obj.each_strongly_connected_component は
obj.strongly_connected_components.each に似ていますが、
ブロックの評価中に obj が変更された場合は予期しない結果になる
ことがあります。

each_strongly_connected_component は nil を返します。

//emlist[使用例][ruby]{
require 'tsort'

class Hash
include TSort
a...

TSort#each_strongly_connected_component_from(node, id_map={}, stack=[]) -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

node から到達可能な強連結成分についてのイテレータです。

node から到達可能な強連結成分についてのイテレータです。

返す値は規定されていません。

each_strongly_connected_component_from は
tsort_each_node を呼びません。

@param node ノードを指定します。

//emlist[例到達可能なノードを表示する][ruby]{
require 'tsort'

class Hash
include TSort
alias tsort_each_node each_key
def tsort_each_child(node, &block)
fetch(node...

Vector#collect -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

ベクトルの各要素に対してブロックを評価した結果を、要素として持つベクトルを生成します。

ベクトルの各要素に対してブロックを評価した結果を、要素として持つベクトルを生成します。

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

//emlist[例][ruby]{
require 'matrix'
a = [1, 2, 3.5, -10]
v1 = Vector.elements(a)
p v1 # => Vector[1, 2, 3.5, -10]
v2 = v1.map{|x|
x * -1
}
p v2 # => Vector[-1, -2, -3.5, 10]
//}

Vector#collect2(v) -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

ベクトルの各要素と引数 v の要素との組に対してブロックを評価し、その結果を要素として持つ配列を返します。

ベクトルの各要素と引数 v の要素との組に対してブロックを評価し、その結果を要素として持つ配列を返します。

ベクトルの各要素と、それに対応するインデックスを持つ引数 v (ベクトル or 配列)の要素との組に対して (2引数の) ブロックを評価し、その結果を要素として持つ配列を返します。

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

@param v ブロック内で評価される(ベクトル or 配列)

@raise ExceptionForMatrix::ErrDimensionMismatch 自分自身と引数のベクト
ルの要素の数(次元)が異なっていたとき...

絞り込み条件を変える

Zlib::GzipReader#each_line(rs = $/) -> Enumerator (18604.0)

2.4.0

インスタンスメソッド

IO クラスの同名メソッドIO#each, IO#each_lineと同じです。

IO クラスの同名メソッドIO#each, IO#each_lineと同じです。

但し、gzip ファイル中に
エラーがあった場合 Zlib::Error 例外や
Zlib::GzipFile::Error 例外が発生します。

gzip ファイルのフッターの処理に注意して下さい。
gzip ファイルのフッターには圧縮前データのチェックサムが
記録されています。GzipReader オブジェクトは、次の時に展開した
データとフッターの照合を行い、エラーがあった場合は
Zlib::GzipFile::NoFooter, Zlib::GzipFile::CRCError,
Zlib::Gzip...

Enumerable#map -> Enumerator (18304.0)

2.4.0

インスタンスメソッド

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

Enumerator::Lazy#zip(*lists) {|v1, v2, ...| ... } -> nil (18304.0)

2.4.0

インスタンスメソッド

Enumerable#zip と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerator::Lazy#force(*args) -> [object] (18004.0)

2.4.0

インスタンスメソッド

全ての要素を含む配列を返します。Lazy から実際に値を取り出すのに使います。

全ての要素を含む配列を返します。Lazy から実際に値を取り出すのに使います。

Enumerable#to_a のエイリアスです。

//emlist[例][ruby]{
1.step.lazy.take(10).force
# => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

1.step.lazy.take(10).to_a
# => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
//}

Enumerator::Yielder#<<(object) -> () (18004.0)

2.4.0

インスタンスメソッド

Enumerator.new で使うメソッドです。

Enumerator.new で使うメソッドです。

生成された Enumerator オブジェクトの each メソッドを呼ぶと
Enumerator::Yielder オブジェクトが渡されたブロックが実行され、
ブロック内の << が呼ばれるたびに each に渡されたブロックが
<< に渡された値とともに繰り返されます。

//emlist[例][ruby]{
enum = Enumerator.new do |y|
y << 1
y << 2
y << 3
end

enum.each do |v|
p v
end
# => 1
# 2
# 3
//}

...

絞り込み条件を変える

IO#each_line(limit, chomp: false) -> Enumerator (9904.0)

2.4.0

インスタンスメソッド

IO の現在位置から 1 行ずつ文字列として読み込み、それを引数として与えられたブロックを実行します。

IO の現在位置から 1 行ずつ文字列として読み込み、それを引数として
与えられたブロックを実行します。

ブロックが与えられなかった場合は、自身から生成した
Enumerator オブジェクトを返します。

テキスト読み込みメソッドとして動作します。

limit で最大読み込みバイト数を指定します。ただしマルチバイト文字が途中で
切れないように余分に読み込む場合があります。

@param rs 行の区切りを文字列で指定します。rs に nil を指定すると行区切りなしとみなします。
空文字列 "" を指定すると連続する改行を行の区切りとみなします(パラグラフモード)...

IO#each_line(rs, limit, chomp: false) -> Enumerator (9904.0)

2.4.0

インスタンスメソッド

IO の現在位置から 1 行ずつ文字列として読み込み、それを引数として与えられたブロックを実行します。

StringIO#each_line(rs = $/) -> Enumerator (9640.0)

2.4.0

インスタンスメソッド

自身から 1 行ずつ読み込み、それを引数として与えられたブロックを実行します。

自身から 1 行ずつ読み込み、それを引数として与えられたブロックを実行します。

@param rs 行の区切りを文字列で指定します。rs に nil を指定すると行区切りなしとみなします。空文字列 "" を指定すると連続する改行を行の区切りとみなします(パラグラフモード)。

@raise IOError 自身が読み取り不可なら発生します。

//emlist[例][ruby]{
require "stringio"
a = StringIO.new("hoge\nfoo\n")
a.each{|l| p l }
#=> "hoge\n"
# "foo\n"
//}

@see $/
...

StringIO#lines(rs = $/) -> Enumerator (9640.0)

2.4.0

インスタンスメソッド

自身から 1 行ずつ読み込み、それを引数として与えられたブロックを実行します。

ARGF.class#each(rs = $/, limit) -> Enumerator (9604.0)

2.4.0

インスタンスメソッド

ARGFの現在位置から 1 行ずつ文字列として読み込み、それを引数として与えられたブロックを実行します。

絞り込み条件を変える

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

2.4.0

インスタンスメソッド

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

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

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

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

//emlist[][ruby]{
enum.chunk {|elt| key }.each {|key, ary| do_something ...

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

2.4.0

インスタンスメソッド

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

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

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

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

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

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

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

2.4.0

インスタンスメソッド

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

Hash#select! -> Enumerator (9604.0)

2.4.0

インスタンスメソッド

キーと値を引数としてブロックを評価した結果が真であるような要素を self に残します。

キーと値を引数としてブロックを評価した結果が真であるような要素を self
に残します。

keep_if は常に self を返します。
select! はオブジェクトが変更された場合に self を、
されていない場合に nil を返します。

ブロックが与えられなかった場合は、自身と keep_if から生成した
Enumerator オブジェクトを返します。

//emlist[例][ruby]{
h1 = {}
c = ("a".."g")
c.each_with_index {|e, i| h1[i] = e }

h2 = h1.dup
h1.select! # => #<E...

IO#each_line(rs = $/, chomp: false) -> Enumerator (9604.0)

2.4.0

インスタンスメソッド

IO の現在位置から 1 行ずつ文字列として読み込み、それを引数として与えられたブロックを実行します。

絞り込み条件を変える

<< 1 2 > >>

別のキーワード

ライブラリ

クラス

モジュール

キーワード

検索結果

先頭5件

Complex#numerator -> Complex (63643.0)

Rational#numerator -> Integer (63379.0)

Float#numerator -> Integer (63343.0)

Enumerator::Lazy#lazy -> self (36304.0)

Enumerator::Yielder#yield(*object) -> () (36304.0)

Enumerator::Lazy#flat_map {|item| ... } -> Enumerator::Lazy (27904.0)

Enumerable#chunk_while {|elt_before, elt_after| ... } -> Enumerator (27604.0)

Enumerable#collect -> Enumerator (27604.0)

Enumerable#collect_concat -> Enumerator (27604.0)

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

Enumerable#drop_while -> Enumerator (27604.0)

Enumerable#flat_map -> Enumerator (27604.0)

Enumerable#take_while -> Enumerator (27604.0)

Enumerator::Lazy#chunk_while {|elt_before, elt_after| ... } -> Enumerator::Lazy (27604.0)

Enumerator::Lazy#collect {|item| ... } -> Enumerator::Lazy (27604.0)

Enumerator::Lazy#collect_concat {|item| ... } -> Enumerator::Lazy (27604.0)

Enumerator::Lazy#drop_while {|item| ... } -> Enumerator::Lazy (27604.0)

Enumerator::Lazy#find_all {|item| ... } -> Enumerator::Lazy (27604.0)

Enumerator::Lazy#select {|item| ... } -> Enumerator::Lazy (27604.0)

Enumerator::Lazy#slice_after {|elt| bool } -> Enumerator::Lazy (27604.0)

Enumerator::Lazy#slice_after(pattern) -> Enumerator::Lazy (27604.0)

Enumerator::Lazy#slice_before {|elt| bool } -> Enumerator::Lazy (27604.0)

Enumerator::Lazy#slice_before(initial_state) {|elt, state| bool } -> Enumerator::Lazy (27604.0)

Enumerator::Lazy#slice_before(pattern) -> Enumerator::Lazy (27604.0)

Enumerator::Lazy#slice_when {|elt_before, elt_after| bool } -> Enumerator::Lazy (27604.0)

Enumerator::Lazy#take_while -> Enumerator::Lazy (27604.0)

Enumerator::Lazy#take_while {|item| ... } -> Enumerator::Lazy (27604.0)

Enumerator#next_values -> Array (27304.0)

Enumerator#peek_values -> Array (27304.0)

ARGF.class#each_line(rs = $/, limit) -> Enumerator (18904.0)

ARGF.class#lines(limit) -> Enumerator (18904.0)

ARGF.class#lines(rs, limit) -> Enumerator (18904.0)

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

IO#lines(limit) -> Enumerator (18904.0)

IO#lines(rs, limit) -> Enumerator (18904.0)

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

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

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

Struct#select -> Enumerator (18640.0)

ARGF.class#each_line(rs = $/) -> Enumerator (18604.0)

ARGF.class#lines(rs = $/) -> Enumerator (18604.0)

Array#collect -> Enumerator (18604.0)

Array#collect! -> Enumerator (18604.0)

Array#cycle(n=nil) -> Enumerator (18604.0)

Array#delete_if -> Enumerator (18604.0)

Array#drop_while -> Enumerator (18604.0)

Array#select -> Enumerator (18604.0)

Array#select! -> Enumerator (18604.0)

Array#take_while -> Enumerator (18604.0)

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

Enumerable#find_all -> Enumerator (18604.0)

Enumerable#select -> Enumerator (18604.0)

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

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

Enumerator::Lazy#chunk {|elt| ... } -> Enumerator::Lazy (18604.0)

Enumerator::Lazy#chunk(initial_state) {|elt, state| ... } -> Enumerator::Lazy (18604.0)

Enumerator::Lazy#drop(n) -> Enumerator::Lazy (18604.0)

Enumerator::Lazy#enum_for(method = :each, *args) -> Enumerator::Lazy (18604.0)

Enumerator::Lazy#enum_for(method = :each, *args) {|*args| block} -> Enumerator::Lazy (18604.0)

Enumerator::Lazy#grep(pattern) {|item| ... } -> Enumerator::Lazy (18604.0)

Enumerator::Lazy#grep_v(pattern) {|item| ... } -> Enumerator::Lazy (18604.0)

Enumerator::Lazy#map {|item| ... } -> Enumerator::Lazy (18604.0)

Enumerator::Lazy#reject {|item| ... } -> Enumerator::Lazy (18604.0)

Enumerator::Lazy#take(n) -> Enumerator::Lazy (18604.0)

Enumerator::Lazy#to_enum(method = :each, *args) -> Enumerator::Lazy (18604.0)

Enumerator::Lazy#to_enum(method = :each, *args) {|*args| block} -> Enumerator::Lazy (18604.0)

Enumerator::Lazy#uniq -> Enumerator::Lazy (18604.0)

Enumerator::Lazy#uniq {|item| ... } -> Enumerator::Lazy (18604.0)

Enumerator::Lazy#zip(*lists) -> Enumerator::Lazy (18604.0)

Hash#delete_if -> Enumerator (18604.0)

Hash#each_value -> Enumerator (18604.0)

Hash#select -> Enumerator (18604.0)

Hash#transform_values -> Enumerator (18604.0)

Enumerator::Lazy#enum_for(method = :each, args) {|args| block} -> Enumerator::Lazy (18604.0)

Enumerator::Lazy#to_enum(method = :each, args) {|args| block} -> Enumerator::Lazy (18604.0)