種類:インスタンスメソッド > バージョン:3.3 > クエリ:_builtin > クエリ:each

218件ヒット [101-200件を表示] （0.309秒）

トップページ >

:インスタンスメソッド

:3.3

:_builtin

:each

別のキーワード

ライブラリ

ビルトイン (218)

クラス

モジュール

Enumerable (42)

キーワード

& (1)
+ (2)
- (1)
<< (1)
[] (1)
^ (1)
append_features (1)
bytes (2)
chars (2)
chunk (3)
chunk_while (1)
clear (1)
close (1)
closed? (1)
codepoints (2)
collect! (2)
collect_concat (1)
count (3)
delete_if (2)
deq (2)
difference (1)
drop (1)
each_byte (6)
each_char (6)
each_child (2)
each_codepoint (6)
each_cons (2)
each_entry (2)
each_grapheme_cluster (2)
each_index (2)
each_key (2)
each_line (12)
each_pair (4)
each_slice (2)
each_value (2)
each_with_index (2)
each_with_object (2)
eager (1)
entries (1)
enum_for (4)
extend_object (1)
feed (1)
filter! (2)
first (2)
flat_map (1)
grapheme_clusters (2)
inject (3)
inplace_mode (1)
instance_method (1)
intersection (1)
invert (1)
join (2)
keep_if (2)
length (1)
lines (2)
map! (2)
merge (1)
next (1)
next_values (1)
pack (2)
peek_values (1)
pop (2)
pos (1)
reduce (3)
rehash (1)
reject! (2)
replace (1)
respond_to? (1)
result (1)
reverse_each (6)
rewind (1)
select! (2)
shift (2)
size (1)
slice_after (4)
slice_before (5)
slice_when (2)
subtract (1)
sum (3)
take (1)
take_while (2)
tell (1)
to_a (1)
to_enum (4)
to_h (2)
to_proc (1)
union (1)
unpack (1)
upto (1)
value (1)
with_index (2)
with_object (2)
yield (1)
zip (4)
| (1)

検索結果

<< < 1 2 3 > >>

String#chars -> [String] (24088.0)

インスタンスメソッド

文字列の各文字を文字列の配列で返します。(self.each_char.to_a と同じです)

文字列の各文字を文字列の配列で返します。(self.each_char.to_a と同じです)

//emlist[例][ruby]{
"hello世界".chars # => ["h", "e", "l", "l", "o", "世", "界"]
//}

ブロックが指定された場合は String#each_char と同じように動作します。

Ruby 2.6 までは deprecated の警告が出ますが、Ruby 2.7 で警告は削除されました。

@see String#each_char

String#chars {|cstr| block } -> self (24088.0)

インスタンスメソッド

文字列の各文字を文字列の配列で返します。(self.each_char.to_a と同じです)

String#codepoints -> [Integer] (24088.0)

インスタンスメソッド

文字列の各コードポイントの配列を返します。(self.each_codepoint.to_a と同じです)

文字列の各コードポイントの配列を返します。(self.each_codepoint.to_a と同じです)

//emlist[例][ruby]{
#coding:UTF-8
"hello わーるど".codepoints
# => [104, 101, 108, 108, 111, 32, 12431, 12540, 12427, 12393]
//}

ブロックが指定された場合は String#each_codepoint と同じように動作します。

Ruby 2.6 までは deprecated の警告が出ますが、Ruby 2.7 で警告は削除されました。

@see String#e...

String#codepoints {|codepoint| block } -> self (24088.0)

インスタンスメソッド

文字列の各コードポイントの配列を返します。(self.each_codepoint.to_a と同じです)

String#grapheme_clusters -> [String] (24088.0)

インスタンスメソッド

文字列の書記素クラスタの配列を返します。(self.each_grapheme_cluster.to_a と同じです)

文字列の書記素クラスタの配列を返します。(self.each_grapheme_cluster.to_a と同じです)

//emlist[例][ruby]{
"a\u0300".grapheme_clusters # => ["à"]
//}

ブロックが指定された場合は String#each_grapheme_cluster と同じように動作します。

Ruby 2.6 までは deprecated の警告が出ますが、Ruby 2.7 で警告は削除されました。

@see String#each_grapheme_cluster

絞り込み条件を変える

String#grapheme_clusters {|grapheme_cluster| block } -> self (24088.0)

インスタンスメソッド

文字列の書記素クラスタの配列を返します。(self.each_grapheme_cluster.to_a と同じです)

String#lines(rs = $/, chomp: false) -> [String] (24088.0)

インスタンスメソッド

文字列中の各行を文字列の配列で返します。(self.each_line.to_a と同じです)

文字列中の各行を文字列の配列で返します。(self.each_line.to_a と同じです)

//emlist[][ruby]{
"aa\nbb\ncc\n".lines # => ["aa\n", "bb\n", "cc\n"]
//}

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

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

...

String#lines(rs = $/, chomp: false) {|line| ... } -> self (24088.0)

インスタンスメソッド

文字列中の各行を文字列の配列で返します。(self.each_line.to_a と同じです)

Enumerator#next -> object (24076.0)

インスタンスメソッド

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

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

現在までの列挙状態に応じて「次」のオブジェクトを返し、列挙状態を1つ分進めます。
列挙が既に最後へ到達している場合は、
StopIteration 例外を発生します。このとき列挙状態は変化しません。
つまりもう一度 next を呼ぶと再び例外が発生します。

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

@raise StopIteration 列挙状態が既に最後へ到達しているとき
@...

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

インスタンスメソッド

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

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

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

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

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

Enumerable#to_a や Enumerable#map ...

絞り込み条件を変える

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

インスタンスメソッド

Enumerator#with_index(offset = 0) -> Enumerator (24058.0)

インスタンスメソッド

生成時のパラメータに従って、要素にインデックスを添えて繰り返します。インデックスは offset から始まります。

生成時のパラメータに従って、要素にインデックスを添えて繰り返します。
インデックスは offset から始まります。

ブロックを指定した場合の戻り値は生成時に指定したレシーバ自身です。

//emlist[例][ruby]{
str = "xyz"

enum = Enumerator.new {|y| str.each_byte {|b| y << b }}
enum.with_index {|byte, idx| p [byte, idx] }
# => [120, 0]
# [121, 1]
# [122, 2]

require "stringi...

Enumerator#with_index(offset = 0) {|(*args), idx| ... } -> object (24058.0)

インスタンスメソッド

生成時のパラメータに従って、要素にインデックスを添えて繰り返します。インデックスは offset から始まります。

Enumerator::Yielder#<<(object) -> () (24058.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
//}

Enumerator::Yielder#yield(*object) -> () (24058.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
# => [...

絞り込み条件を変える

StopIteration#result -> object (24058.0)

インスタンスメソッド

この例外オブジェクトを発生させる原因となったメソッド等の返り値を返します。

この例外オブジェクトを発生させる原因となったメソッド等の返り値を返します。

object = Object.new
def object.each
yield :yield1
yield :yield2
:each_returned
end

enumerator = object.to_enum

p enumerator.next #=> :yield1
p enumerator.next #=> :yield2

begin
enumerator.next
rescue StopIteration => error
...

ARGF.class#inplace_mode -> String | nil (24040.0)

インスタンスメソッド

c:ARGF#inplace で書き換えるファイルのバックアップに付加される拡張子を返します。拡張子が設定されていない場合は空文字列を返します。インプレースモードでない場合は nil を返します。

c:ARGF#inplace で書き換えるファイルのバックアップに付加される拡
張子を返します。拡張子が設定されていない場合は空文字列を返します。イン
プレースモードでない場合は nil を返します。

Ruby 起動時の -i オプションや ARGF.class#inplace_mode= で設定します。

例:
# $ echo "test" > test.txt
# $ ruby -i.bak test.rb test.txt
# $ cat test.txt # => "TEST"
# $ cat test.txt.bak # => "test"

# test...

Array#delete_if -> Enumerator (24040.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#delete_if {|x| ... } -> self (24040.0)

インスタンスメソッド

Array#pack(template) -> String (24040.0)

インスタンスメソッド

配列の内容を template で指定された文字列にしたがって、バイナリとしてパックした文字列を返します。

配列の内容を template で指定された文字列にしたがって、
バイナリとしてパックした文字列を返します。

テンプレートは
型指定文字列とその長さ(省略時は1)を並べたものです。長さと
して * が指定された時は「残りのデータ全て」の長さを
表します。型指定文字は以下で述べる pack テンプレート文字列の通りです。

buffer が指定されていれば、バッファとして使って返値として返します。
もし template の最初にオフセット (@) が指定されていれば、
結果はオフセットの後ろから詰められます。
buffer の元の内容がオフセットより長ければ、
オフセットより後ろの部分は上...

絞り込み条件を変える

Array#pack(template, buffer: String.new) -> String (24040.0)

インスタンスメソッド

配列の内容を template で指定された文字列にしたがって、バイナリとしてパックした文字列を返します。

Array#reject! -> Enumerator (24040.0)

インスタンスメソッド

Array#reject! {|x| ... } -> self | nil (24040.0)

インスタンスメソッド

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

インスタンスメソッド

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

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

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

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

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

Enumerable#first -> object | nil (24040.0)

インスタンスメソッド

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

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

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

@param n 取得する要素数。

//emlist[例][ruby]{
e = "abcd".each_byte
e.first #=> 97
e.first(2) #=> [97,98]
e = "".each_byte
e.first #=> nil
e.first(2) #=> []
//}

絞り込み条件を変える

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

インスタンスメソッド

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

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

インスタンスメソッド

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

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

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

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

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

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

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

インスタンスメソッド

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

インスタンスメソッド

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

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

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

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

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

Enumerable#to_h(*args) -> Hash (24040.0)

インスタンスメソッド

self を [key, value] のペアの配列として解析した結果を Hash にして返します。

self を [key, value] のペアの配列として解析した結果を Hash にして
返します。

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

//emlist[例][ruby]{
%i[hello world].each_with_index.to_h # => {:hello => 0, :world => 1}
//}

ブロックを指定すると各要素でブロックを呼び出し、
その結果をペアとして使います。

//emlist[ブロック付きの例][ruby]{
(1..5).to_h {|x| [x, x ** 2]} # => {1=>1, 2=>4, ...

絞り込み条件を変える

Enumerable#to_h(*args) { ... } -> Hash (24040.0)

インスタンスメソッド

self を [key, value] のペアの配列として解析した結果を Hash にして返します。

Enumerator#next_values -> Array (24040.0)

インスタンスメソッド

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

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

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

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

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

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

Enumerator#with_object(obj) -> Enumerator (24040.0)

インスタンスメソッド

繰り返しの各要素に obj を添えてブロックを繰り返し、obj を返り値として返します。

繰り返しの各要素に obj を添えてブロックを繰り返し、obj を返り値として返します。

obj には任意のオブジェクトを渡すことができます。

ブロックが渡されなかった場合は、上で説明した繰り返しを実行し、
最後に obj を返す Enumerator を返します。

//emlist[例][ruby]{
# 0,1,2 と呼びだす enumeratorを作る
to_three = Enumerator.new do |y|
3.times do |x|
y << x
end
end

to_three_with_string = to_three.with_object...

Enumerator#with_object(obj) {|(*args), memo_obj| ... } -> object (24040.0)

インスタンスメソッド

繰り返しの各要素に obj を添えてブロックを繰り返し、obj を返り値として返します。

Enumerator::Lazy#collect_concat {|item| ... } -> Enumerator::Lazy (24040.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) ...

絞り込み条件を変える

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

インスタンスメソッド

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

Enumerator::Yielder#to_proc -> Proc (24040.0)

インスタンスメソッド

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

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

引数を Enumerator::Yielder#yield に渡す Proc を返します。
これは Enumerator::Yielder オブジェクトを他のメソッドにブロック引数と
して直接渡すために使えます。

//emlist[例][ruby]{
text = <<-END
Hello
こんにちは
END

enum = Enumerator.new do |y|
text.each_line(&y)
end

enum.each do |line|
p line
end
# => "Hello\n"
# "こんにちは...

Object#respond_to?(name, include_all = false) -> bool (24040.0)

インスタンスメソッド

オブジェクトがメソッド name を持つとき真を返します。

オブジェクトがメソッド name を持つとき真を返します。

オブジェクトがメソッド name を持つというのは、
オブジェクトがメソッド name に応答できることをいいます。

Windows での Process.fork や GNU/Linux での File.lchmod の
ような NotImplementedError が発生する場合は false を返します。

※ NotImplementedError が発生する場合に false を返すのは
Rubyの組み込みライブラリや標準ライブラリなど、C言語で実装されているメソッドのみです。
Rubyで実装されたメソッドで N...

Set#&(enum) -> Set (24040.0)

インスタンスメソッド

共通部分、すなわち、2つの集合のいずれにも属するすべての要素からなる新しい集合を作ります。

共通部分、すなわち、2つの集合のいずれにも属するすべての要素からなる
新しい集合を作ります。

@param enum each メソッドが定義されたオブジェクトを指定します。
@raise ArgumentError 引数 enum に each メソッドが定義されていない場合に
発生します。

//emlist[][ruby]{
s1 = Set[10, 20, 30]
s2 = Set[10, 30, 50]
p s1 & s2 #=> #<Set: {10, 30}>
//}

@see Array#&, Array#intersection

Set#+(enum) -> Set (24040.0)

インスタンスメソッド

和集合、すなわち、2 つの集合の少なくともどちらか一方に属するすべての要素からなる新しい集合を作ります。

和集合、すなわち、2 つの集合の少なくともどちらか一方に属するすべての
要素からなる新しい集合を作ります。

@param enum each メソッドが定義されたオブジェクトを指定します。
@raise ArgumentError 引数 enum に each メソッドが定義されていない場合に
発生します。

//emlist[][ruby]{
p Set[10, 20, 30] + Set[10, 20, 40]
# => #<Set: {10, 20, 30, 40}>
//}

絞り込み条件を変える

Set#-(enum) -> Set (24040.0)

インスタンスメソッド

差集合、すなわち、元の集合の要素のうち引数 enum に含まれる要素を取り除いた新しい集合を作ります。

差集合、すなわち、元の集合の要素のうち引数 enum に含まれる要素を取り除いた
新しい集合を作ります。

@param enum each メソッドが定義されたオブジェクトを指定します。
@raise ArgumentError 引数 enum に each メソッドが定義されていない場合に
発生します。

//emlist[][ruby]{
p Set[10, 20, 30] - Set[10, 20, 40]
# => #<Set: {30}>
//}

Set#^(enum) -> Set (24040.0)

インスタンスメソッド

対称差、すなわち、2 つの集合のいずれか一方にだけ属するすべての要素からなる新しい集合を作ります。

対称差、すなわち、2 つの集合のいずれか一方にだけ属するすべての要素からなる
新しい集合を作ります。

@param enum each メソッドが定義されたオブジェクトを指定します。
@raise ArgumentError 引数 enum に each メソッドが定義されていない場合に
発生します。

//emlist[][ruby]{
s1 = Set[10, 20, 30]
s2 = Set[10, 30, 50]
p s1 ^ s2 # => #<Set: {50, 20}>
//}

Set#difference(enum) -> Set (24040.0)

インスタンスメソッド

差集合、すなわち、元の集合の要素のうち引数 enum に含まれる要素を取り除いた新しい集合を作ります。

Set#intersection(enum) -> Set (24040.0)

インスタンスメソッド

共通部分、すなわち、2つの集合のいずれにも属するすべての要素からなる新しい集合を作ります。

Set#merge(enum) -> self (24040.0)

インスタンスメソッド

元の集合に enum で与えられた要素を追加します。

元の集合に enum で与えられた要素を追加します。

引数 enum には each メソッドが定義されている必要があります。

@param enum 追加対象の要素を格納したオブジェクトを指定します。
@raise ArgumentError 引数 enum に each メソッドが定義されていない場合に
発生します。

//emlist[][ruby]{
set = Set[10, 20]
set.merge([10, 30])
p set # => #<Set: {10, 20, 30}>
//}

絞り込み条件を変える

Set#replace(enum) -> self (24040.0)

インスタンスメソッド

集合の要素をすべて削除し、enum で与えられた要素に置き換えます。

集合の要素をすべて削除し、enum で与えられた要素に置き換えます。

引数 enum には each メソッドが定義されている必要があります。

@param enum 置き換え後の集合要素を格納するオブジェクトを指定します。
@raise ArgumentError 引数 enum に each メソッドが定義されていない場合に
発生します。

//emlist[][ruby]{
p s = Set[10, 20, 30] # => #<Set: {10, 20, 30}>
s.replace([15, 25])
p s # => #<Set: {15, 25}>
//}
...

Set#subtract(enum) -> self (24040.0)

インスタンスメソッド

元の集合から、enum で与えられた要素を削除します。

元の集合から、enum で与えられた要素を削除します。

引数 enum には each メソッドが定義されている必要があります。

@param enum 削除対象の要素を格納したオブジェクトを指定します。
@raise ArgumentError 引数 enum に each メソッドが定義されていない場合に
発生します。

//emlist[][ruby]{
set = Set[10, 20, 40]
set.subtract([10, 20, 30])
p set # => #<Set: {40}>
//}

Set#union(enum) -> Set (24040.0)

インスタンスメソッド

和集合、すなわち、2 つの集合の少なくともどちらか一方に属するすべての要素からなる新しい集合を作ります。

Set#|(enum) -> Set (24040.0)

インスタンスメソッド

和集合、すなわち、2 つの集合の少なくともどちらか一方に属するすべての要素からなる新しい集合を作ります。

String#sum(bits = 16) -> Integer (24040.0)

インスタンスメソッド

文字列の bits ビットのチェックサムを計算します。

文字列の bits ビットのチェックサムを計算します。

以下と同じです。

//emlist[][ruby]{
def sum(bits)
sum = 0
each_byte {|c| sum += c }
return 0 if sum == 0
sum & ((1 << bits) - 1)
end
//}

例えば以下のコードで UNIX System V の
sum(1) コマンドと同じ値が得られます。

//emlist[例][ruby]{
sum = 0
ARGF.each_line do |line|
sum += line.sum
end
sum %= ...

絞り込み条件を変える

String#unpack(template) -> Array (24040.0)

インスタンスメソッド

Array#pack で生成された文字列をテンプレート文字列 template にしたがってアンパックし、それらの要素を含む配列を返します。

Array#pack で生成された文字列を
テンプレート文字列 template にしたがってアンパックし、
それらの要素を含む配列を返します。

@param template pack テンプレート文字列
@return オブジェクトの配列

以下にあげるものは、Array#pack、String#unpack、String#unpack1
のテンプレート文字の一覧です。テンプレート文字は後に「長さ」を表す数字
を続けることができます。「長さ」の代わりに`*'とすることで「残り全て」
を表すこともできます。

長さの意味はテンプレート文字により異なりますが大...

Thread#value -> object (24040.0)

インスタンスメソッド

スレッド self が終了するまで待ち(Thread#join と同じ)、そのスレッドのブロックが返した値を返します。スレッド実行中に例外が発生した場合には、その例外を再発生させます。

スレッド self が終了するまで待ち(Thread#join と同じ)、
そのスレッドのブロックが返した値を返します。スレッド実行中に例外が
発生した場合には、その例外を再発生させます。

スレッドが Thread#kill によって終了した場合は、返り値は不定です。

以下は、生成したすべてのスレッドの終了を待ち結果を出力する例です。

threads = []
threads.push(Thread.new { n = rand(5); sleep n; n })
threads.push(Thread.new { n = rand(5); sleep n; n })...

Thread::Queue#deq(non_block = false) -> object (24040.0)

インスタンスメソッド

キューからひとつ値を取り出します。キューが空の時、呼出元のスレッドは停止します。

キューからひとつ値を取り出します。キューが空の時、呼出元のスレッドは停止します。

@param non_block true を与えると、キューが空の時に例外 ThreadError が発生します。

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

q = Queue.new

th1 = Thread.start do
while resource = q.pop
puts resource
end
end

[:resource1, :resource2, :resource3, nil].each { |r|
q.push(r)
}

t...

Thread::Queue#pop(non_block = false) -> object (24040.0)

インスタンスメソッド

キューからひとつ値を取り出します。キューが空の時、呼出元のスレッドは停止します。

Thread::Queue#shift(non_block = false) -> object (24040.0)

インスタンスメソッド

キューからひとつ値を取り出します。キューが空の時、呼出元のスレッドは停止します。

絞り込み条件を変える

Thread::SizedQueue#deq(non_block = false) -> object (24040.0)

インスタンスメソッド

キューからひとつ値を取り出します。キューに push しようと待っているスレッドがあれば、実行を再開させます。

キューからひとつ値を取り出します。
キューに push しようと待っているスレッドがあれば、実行を再開させます。

@param non_block true を与えると、キューが空の時に例外 ThreadError が発生します。

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

q = SizedQueue.new(4)

th1 = Thread.start do
while resource = q.pop
puts resource
end
end

[:resource1, :resource2, :resource3, nil].eac...

Thread::SizedQueue#pop(non_block = false) -> object (24040.0)

インスタンスメソッド

キューからひとつ値を取り出します。キューに push しようと待っているスレッドがあれば、実行を再開させます。

Thread::SizedQueue#shift(non_block = false) -> object (24040.0)

インスタンスメソッド

キューからひとつ値を取り出します。キューに push しようと待っているスレッドがあれば、実行を再開させます。

Array#collect! -> Enumerator (24022.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#collect! {|item| ..} -> self (24022.0)

インスタンスメソッド

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

絞り込み条件を変える

Array#map! -> Enumerator (24022.0)

インスタンスメソッド

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

Array#map! {|item| ..} -> self (24022.0)

インスタンスメソッド

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

Array#zip(*lists) -> [[object]] (24022.0)

インスタンスメソッド

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

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

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

@param lists 配列を指定します。
配列以外のオブジェクトを指定した場合は to_ary メソッドによ
る暗黙の型変換を試みます。to_ary メソッドに応答できない場
合は each メソッドによる暗黙の型変換を試みます。

@raise TypeError 引数に配列以外の...

Array#zip(*lists) {|v1, v2, ...| ...} -> nil (24022.0)

インスタンスメソッド

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

Dir#pos -> Integer (24022.0)

インスタンスメソッド

ディレクトリストリームの現在の位置を整数で返します。

ディレクトリストリームの現在の位置を整数で返します。

@raise IOError 既に自身が close している場合に発生します。

//emlist[例][ruby]{
Dir.open("/tmp") {|d|
d.each {|f|
p d.pos
}
}
//}

絞り込み条件を変える

Dir#tell -> Integer (24022.0)

インスタンスメソッド

ディレクトリストリームの現在の位置を整数で返します。

Enumerable#count -> Integer (24022.0)

インスタンスメソッド

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

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

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

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

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

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

//emlist[例][ruby]{
enum = [1, 2, 4, 2].each
enum.count # => 4
enum.count(2) ...

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

インスタンスメソッド

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

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

インスタンスメソッド

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

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

インスタンスメソッド

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

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

@param n 捨てる要素数。

//emlist[例][ruby]{
e = [1, 2, 3, 4, 5, 0].each
e.drop(3) # => [4, 5, 0]
//}

@see Array#drop

絞り込み条件を変える

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

インスタンスメソッド

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

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

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

//emlist[例][ruby]{
(1..7).to_a #=> [1, 2, 3, 4, 5, 6, 7]
{ 'a'=>1, 'b'=>2, 'c'=>3 }.to_a #=> [["a", 1], ["b", 2], ["c", 3]]

require 'prime'
Prime.entries 10 #=> [2, 3, 5, 7]
//}

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

インスタンスメソッド

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

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

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

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

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

@param in...

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

インスタンスメソッド

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

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

インスタンスメソッド

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

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

インスタンスメソッド

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

絞り込み条件を変える

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

インスタンスメソッド

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

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

インスタンスメソッド

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

Enumerable#sum(init=0) -> object (24022.0)

インスタンスメソッド

要素の合計を返します。

要素の合計を返します。

ブロックが与えられた場合、加算する前に各要素にブロックが適用されます。

selfが空の場合、initを返します。

//emlist[例][ruby]{
{ 1 => 10, 2 => 20 }.sum {|k, v| k * v } # => 50
(1..10).sum # => 55
(1..10).sum {|v| v * 2 } # => 110
('a'..'z').sum # => TypeError
...

Enumerable#sum(init=0) {|e| expr } -> object (24022.0)

インスタンスメソッド

要素の合計を返します。

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

インスタンスメソッド

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

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

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

//emlist[例][ruby]{
e = [1, 2, 3, 4, 5, 0].each
e.take(3) # => [1, 2, 3]
//}

@see Array#take

絞り込み条件を変える

Enumerable#take_while -> Enumerator (24022.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

Enumerable#take_while {|element| ... } -> Array (24022.0)

インスタンスメソッド

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

Enumerable#to_a(*args) -> [object] (24022.0)

インスタンスメソッド

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

Enumerable#zip(*lists) -> [[object]] (24022.0)

インスタンスメソッド

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

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

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

@param lists 配列を指定します。配列でない場合は to_ary メソッドにより配列に変換します。
to_ary メソッドが無い場合は each を試します。

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

Enumerable#zip(*lists) {|v1, v2, ...| ...} -> nil (24022.0)

インスタンスメソッド

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

絞り込み条件を変える

Enumerator#+(enum) -> Enumerator::Chain (24022.0)

インスタンスメソッド

自身と enum 引数を続けて繰り返す Enumerator::Chain を返します。

自身と enum 引数を続けて繰り返す Enumerator::Chain を返します。

//emlist[例][ruby]{
e = (1..3).each + [4, 5]
e.to_a #=> [1, 2, 3, 4, 5]
//}

@see Enumerable#chain

Enumerator#feed(obj) -> nil (24022.0)

インスタンスメソッド

Enumerator 内部の yield が返す値を設定します。

Enumerator 内部の yield が返す値を設定します。

これで値を設定しなかった場合は yield は nil を返します。

この値は内部で yield された時点でクリアされます。

//emlist[例][ruby]{
# (1), (2), ... (10) の順に実行される
o = Object.new
def o.each
x = yield # (2) blocks
p x # (5) => "foo"
x = yield # (6) blocks
p x # (...

Enumerator#peek_values -> Array (24022.0)

インスタンスメソッド

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

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

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

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

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

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

Enumerator#rewind -> self (24022.0)

インスタンスメソッド

列挙状態を巻き戻します。

列挙状態を巻き戻します。

next メソッドによる外部列挙の状態を最初まで巻き戻します。 self を返します。

内包するオブジェクトが rewind メソッドを持つとき(respond_to?(:rewind) に
真を返すとき) は、その rewind メソッドを呼び出します。

@see Enumerator#next

//emlist[例][ruby]{
str = "xyz"
enum = str.each_byte

p enum.next # => 120
p enum.next # => 121
enum.rewind
p enum.next # => 120
//}

Enumerator::Lazy#chunk {|elt| ... } -> Enumerator::Lazy (24022.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 (24022.0)

インスタンスメソッド

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

Enumerator::Lazy#eager -> Enumerator (24022.0)

インスタンスメソッド

自身を遅延評価しない Enumerator に変換して返します。

自身を遅延評価しない Enumerator に変換して返します。

//emlist[例][ruby]{
lazy_enum = (1..).each.lazy

# select が遅延評価されるので終了する
p lazy_enum.class # => Enumerator::Lazy
p lazy_enum.select { |n| n.even? }.first(5)
# => [2, 4, 6, 8, 10]

# select が遅延評価されないので終了しない
enum = lazy_enum.eager
p enum.class # => Enumerator
p enum.s...

Enumerator::Lazy#slice_after {|elt| bool } -> Enumerator::Lazy (24022.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 (24022.0)

インスタンスメソッド

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

Enumerator::Lazy#slice_before {|elt| bool } -> Enumerator::Lazy (24022.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 (24022.0)

インスタンスメソッド

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

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

インスタンスメソッド

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

Enumerator::Lazy#slice_when {|elt_before, elt_after| bool } -> Enumerator::Lazy (24022.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]...

Hash#filter! -> Enumerator (24022.0)

インスタンスメソッド

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

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

keep_if は常に self を返します。
filter! と 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!...

Hash#filter! {|key, value| ... } -> self | nil (24022.0)

インスタンスメソッド

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

絞り込み条件を変える

<< < 1 2 3 > >>

別のキーワード

ライブラリ

クラス

モジュール

キーワード

検索結果

先頭5件

String#chars -> [String] (24088.0)

String#chars {|cstr| block } -> self (24088.0)

String#codepoints -> [Integer] (24088.0)

String#codepoints {|codepoint| block } -> self (24088.0)

String#grapheme_clusters -> [String] (24088.0)

String#grapheme_clusters {|grapheme_cluster| block } -> self (24088.0)

String#lines(rs = $/, chomp: false) -> [String] (24088.0)

String#lines(rs = $/, chomp: false) {|line| ... } -> self (24088.0)

Enumerator#next -> object (24076.0)

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

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

Enumerator#with_index(offset = 0) -> Enumerator (24058.0)

Enumerator#with_index(offset = 0) {|(*args), idx| ... } -> object (24058.0)

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

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

StopIteration#result -> object (24058.0)

ARGF.class#inplace_mode -> String | nil (24040.0)

Array#delete_if -> Enumerator (24040.0)

Array#delete_if {|x| ... } -> self (24040.0)

Array#pack(template) -> String (24040.0)

Array#pack(template, buffer: String.new) -> String (24040.0)

Array#reject! -> Enumerator (24040.0)

Array#reject! {|x| ... } -> self | nil (24040.0)

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

Enumerable#first -> object | nil (24040.0)

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

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

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

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

Enumerable#to_h(*args) -> Hash (24040.0)

Enumerable#to_h(*args) { ... } -> Hash (24040.0)

Enumerator#next_values -> Array (24040.0)

Enumerator#with_object(obj) -> Enumerator (24040.0)

Enumerator#with_object(obj) {|(*args), memo_obj| ... } -> object (24040.0)

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

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

Enumerator::Yielder#to_proc -> Proc (24040.0)

Object#respond_to?(name, include_all = false) -> bool (24040.0)

Set#&(enum) -> Set (24040.0)

Set#+(enum) -> Set (24040.0)

Set#-(enum) -> Set (24040.0)

Set#^(enum) -> Set (24040.0)

Set#difference(enum) -> Set (24040.0)

Set#intersection(enum) -> Set (24040.0)

Set#merge(enum) -> self (24040.0)

Set#replace(enum) -> self (24040.0)

Set#subtract(enum) -> self (24040.0)

Set#union(enum) -> Set (24040.0)

Set#|(enum) -> Set (24040.0)

String#sum(bits = 16) -> Integer (24040.0)

String#unpack(template) -> Array (24040.0)

Thread#value -> object (24040.0)

Thread::Queue#deq(non_block = false) -> object (24040.0)

Thread::Queue#pop(non_block = false) -> object (24040.0)

Thread::Queue#shift(non_block = false) -> object (24040.0)

Thread::SizedQueue#deq(non_block = false) -> object (24040.0)

Thread::SizedQueue#pop(non_block = false) -> object (24040.0)

Thread::SizedQueue#shift(non_block = false) -> object (24040.0)

Array#collect! -> Enumerator (24022.0)

Array#collect! {|item| ..} -> self (24022.0)

Array#map! -> Enumerator (24022.0)

Array#map! {|item| ..} -> self (24022.0)

Array#zip(*lists) -> [[object]] (24022.0)

Array#zip(*lists) {|v1, v2, ...| ...} -> nil (24022.0)

Dir#pos -> Integer (24022.0)

Dir#tell -> Integer (24022.0)

Enumerable#count -> Integer (24022.0)

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

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

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

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

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

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