バージョン:2.1.0 > クエリ:_builtin > クエリ:== > クエリ:|

126件ヒット [1-100件を表示] （0.052秒）

トップページ >

:2.1.0

:_builtin

:==

別のキーワード

種類

ライブラリ

ビルトイン (126)

クラス

ARGF.class (8)
Array (23)
Enumerator (2)
Enumerator::Lazy (7)
Exception (1)
FalseClass (1)
File (1)
Hash (7)
Numeric (1)
Proc (4)
Range (4)
RubyVM::InstructionSequence (2)
String (14)
Symbol (1)
TrueClass (1)

モジュール

Enumerable (34)
Process (1)

オブジェクト

ENV (12)

キーワード

=== (1)
Lazy (1)
Numeric (1)
[] (7)
assoc (2)
call (1)
chunk (2)
chunk_while (1)
collect (1)
count (6)
delete (2)
delete_if (4)
detect (2)
disasm (1)
disassemble (1)
each (6)
each_key (2)
each_line (4)
each_pair (2)
find (2)
find_all (2)
find_index (6)
getrlimit (1)
index (3)
keep_if (2)
lazy (1)
lstat (1)
map (1)
max (6)
min (6)
new (2)
none? (2)
one? (2)
pack (1)
partition (2)
rassoc (2)
reject (6)
reject! (4)
remainder (1)
rindex (3)
select (2)
select! (2)
slice (6)
slice_before (3)
sort (2)
sum (1)
to_h (1)
unpack (1)
yield (1)

検索結果

<< 1 2 > >>

Symbol#==(other) -> true | false (78640.0)

2.1.0

インスタンスメソッド

other が同じシンボルの時に真を返します。そうでない場合は偽を返します。

other が同じシンボルの時に真を返します。
そうでない場合は偽を返します。

@param other 比較対象のシンボルを指定します。

例:

:aaa == :aaa #=> true
:aaa == :xxx #=> false

Exception#==(other) -> bool (78511.0)

2.1.0

インスタンスメソッド

自身と指定された other のクラスが同じであり、 message と backtrace が == メソッドで比較して等しい場合に true を返します。そうでない場合に false を返します。

自身と指定された other のクラスが同じであり、
message と backtrace が == メソッドで比較して
等しい場合に true を返します。そうでない場合に false を返します。

@param other 自身と比較したいオブジェクトを指定します。
自身と異なるクラスのオブジェクトを指定した場合は
Exception#exception を実行して変換を試みます。

//emlist[例][ruby]{
require "date"
def check_long_month(month)
return if D...

FalseClass#|(other) -> bool (78463.0)

2.1.0

インスタンスメソッド

other が真なら true を, 偽なら false を返します。

other が真なら true を, 偽なら false を返します。

@param other 論理和を行なう式です。

| は再定義可能な演算子に分類されていますので、通常は false | other の形で使われます。

//emlist[例][ruby]{
p false | true #=> true
p false | false #=> false
p false | nil #=> false
p false | (1 == 1) #=> true
p false | (1 + 1) #=> true

p false.|(true) #=...

TrueClass#|(other) -> bool (78463.0)

2.1.0

インスタンスメソッド

常に true を返します。

常に true を返します。

@param other 論理和を行なう式です。

| は再定義可能な演算子に分類されていますので、通常は true | other のように使われます。

//emlist[例][ruby]{
p true | true #=> true
p true | false #=> true
p true | nil #=> true
p true | (1 == 1) #=> true
p true | (1 + 1) #=> true

p true.|(true) #=> true
p true.|(false) #=> ...

Proc#===(*arg) -> () (60655.0)

2.1.0

インスタンスメソッド

手続きオブジェクトを実行してその結果を返します。

手続きオブジェクトを実行してその結果を返します。

引数の渡され方はオブジェクトの生成方法によって異なります。
詳しくは Proc#lambda? を参照してください。

「===」は when の所に手続きを渡せるようにするためのものです。

//emlist[例][ruby]{
def sign(n)
case n
when lambda{|n| n > 0} then 1
when lambda{|n| n < 0} then -1
else 0
end
end

p sign(-4) #=> -1
p sign(0) #=> 0
p sign(7) #=> 1...

絞り込み条件を変える

Proc#[](*arg) -> () (42055.0)

2.1.0

インスタンスメソッド

手続きオブジェクトを実行してその結果を返します。

Proc#call(*arg) -> () (42055.0)

2.1.0

インスタンスメソッド

手続きオブジェクトを実行してその結果を返します。

Proc#yield(*arg) -> () (42055.0)

2.1.0

インスタンスメソッド

手続きオブジェクトを実行してその結果を返します。

Numeric (25639.0)

2.1.0

クラス

数値を表す抽象クラスです。Integer や Float などの数値クラスは Numeric のサブクラスとして実装されています。

数値を表す抽象クラスです。Integer や Float などの数値クラス
は Numeric のサブクラスとして実装されています。

演算や比較を行うメソッド(+, -, *, /, <=>)は Numeric のサブクラスで定義されま
す。Numeric で定義されているメソッドは、サブクラスで提供されているメソッド
(+, -, *, /, %) を利用して定義されるものがほとんどです。
つまり Numeric で定義されているメソッドは、Numeric のサブクラスとして新たに数値クラスを定義した時に、
演算メソッド(+, -, *, /, %, <=>, coerce)だけを定義すれ...

Hash#keep_if {|key, value| ... } -> self (24508.0)

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

絞り込み条件を変える

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

2.1.0

インスタンスメソッド

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

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

2.1.0

インスタンスメソッド

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

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

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

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

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

ENV.delete_if {|key, value| ... } -> ENV (24454.0)

2.1.0

特異メソッド

key と value を引数としてブロックを評価した値が真である時、環境変数を削除します。

key と value を引数としてブロックを評価した値が真であ
る時、環境変数を削除します。

reject! は要素に変化がなければ nil を返します。

//emlist[][ruby]{
ENV['FOO'] = 'bar'
ENV.delete_if { |key, value| key == 'FOO' && value == 'bar' } # => ENV
ENV.reject! { |key, value| key == 'FOO' && value == 'bar' } # => nil
//}

ENV.reject! {|key, value| ... } -> ENV | nil (24454.0)

2.1.0

特異メソッド

key と value を引数としてブロックを評価した値が真である時、環境変数を削除します。

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

2.1.0

インスタンスメソッド

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

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

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

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

//emlist[例][ruby]{
(1..10).find_index(11) #=> nil
(1..10).find_index(2) #=> 1
//}

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

/...

絞り込み条件を変える

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

2.1.0

インスタンスメソッド

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

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

2.1.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) {|item| ... } -> object (24415.0)

2.1.0

インスタンスメソッド

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

Enumerator.new(size=nil) {|y| ... } -> Enumerator (24415.0)

2.1.0

特異メソッド

Enumerator オブジェクトを生成して返します。与えられたブロックは Enumerator::Yielder オブジェクトを引数として実行されます。

Enumerator オブジェクトを生成して返します。与えられたブロックは Enumerator::Yielder オブジェクトを
引数として実行されます。

生成された Enumerator オブジェクトに対して each を呼ぶと、この生成時に指定されたブロックを
実行し、Yielder オブジェクトに対して << メソッドが呼ばれるたびに、
each に渡されたブロックが繰り返されます。

new に渡されたブロックが終了した時点で each の繰り返しが終わります。
このときのブロックの返り値が each の返り値となります。

@param size 生成する Enumerator...

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

2.1.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 (24415.0)

2.1.0

インスタンスメソッド

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

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

2.1.0

インスタンスメソッド

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

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

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

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

@param n 取得する要素数。

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

//emlist[例][ruby]{
class Person
...

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

2.1.0

インスタンスメソッド

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

2.1.0

インスタンスメソッド

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

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

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

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

@param n 取得する要素数。

//emlist[例][ruby]{
class Person
attr_reader :name, :age

def initialize...

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

2.1.0

インスタンスメソッド

絞り込み条件を変える

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

2.1.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 {|item| ... } -> [object] (24397.0)

2.1.0

インスタンスメソッド

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

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

2.1.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#map {|item| ... } -> Enumerator::Lazy (24397.0)

2.1.0

インスタンスメソッド

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

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

2.1.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 (24397.0)

2.1.0

インスタンスメソッド

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

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

2.1.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#reject! {|x| ... } -> self | nil (24382.0)

2.1.0

インスタンスメソッド

ARGF.class#each(rs = $/) { |line| ... } -> self (24379.0)

2.1.0

インスタンスメソッド

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

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

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

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

...

ARGF.class#each(rs = $/, limit) { |line| ... } -> self (24379.0)

2.1.0

インスタンスメソッド

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

絞り込み条件を変える

ARGF.class#each_line(rs = $/) { |line| ... } -> self (24379.0)

2.1.0

インスタンスメソッド

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

ARGF.class#each_line(rs = $/, limit) { |line| ... } -> self (24379.0)

2.1.0

インスタンスメソッド

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

String#[](nth) -> String | nil (24379.0)

2.1.0

インスタンスメソッド

nth 番目の文字を返します。 nth が負の場合は文字列の末尾から数えます。つまり、 self.size + nth 番目の文字を返します。

nth 番目の文字を返します。
nth が負の場合は文字列の末尾から数えます。
つまり、 self.size + nth 番目の文字を返します。

nth が範囲外を指す場合は nil を返します。

@param nth 文字の位置を表す整数
@return 指定した位置の文字を表す String オブジェクト

//emlist[例][ruby]{
p 'bar'[2] # => "r"
p 'bar'[2] == ?r # => true
p 'bar'[-1] # => "r"
p 'bar'[3] # => nil
p 'bar'[-4] ...

String#slice(nth) -> String | nil (24379.0)

2.1.0

インスタンスメソッド

nth 番目の文字を返します。 nth が負の場合は文字列の末尾から数えます。つまり、 self.size + nth 番目の文字を返します。

Array#rindex {|item| ... } -> Integer | nil (24376.0)

2.1.0

インスタンスメソッド

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

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

ブロックが与えられた時には、各要素を右(末尾)から順に引数としてブロックを実行し、
ブロックが真を返す最初の要素の位置を返します。
ブロックが真を返す要素がなかった時には nil を返します。

引数、ブロックのどちらも与えられなかった時には、自身と rindex から生成した
Enumerator オブジェクトを返します。

@param val オブジェクトを指定します。

//emlist[例][ruby]{
p [1, 0, 0, 1, 0].rindex(...

絞り込み条件を変える

Array#rindex(val) -> Integer | nil (24376.0)

2.1.0

インスタンスメソッド

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

Range#max {|a, b| ... } -> object | nil (24364.0)

2.1.0

インスタンスメソッド

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

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

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

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

@see Range#last, Range#min, Enumerable#max

//emlist[例][ruby]{
h = { 1 => "C", 2 => "Go", 3 => "Ruby" }
(1..3).max { |a, b| h[a].leng...

Range#min {|a, b| ... } -> object | nil (24364.0)

2.1.0

インスタンスメソッド

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

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

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

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

@see Range#first, Range#max, Enumerable#min

//emlist[例][ruby]{
h = { 1 => "C", 2 => "Go", 3 => "Ruby" }
(1..3).min { |a, b| h[a].len...

String#[](nth, len) -> String | nil (24364.0)

2.1.0

インスタンスメソッド

nth 文字目から長さ len 文字の部分文字列を新しく作って返します。 nth が負の場合は文字列の末尾から数えます。

nth 文字目から長さ len 文字の部分文字列を新しく作って返します。
nth が負の場合は文字列の末尾から数えます。

@param nth 取得したい文字列の開始インデックスを整数で指定します。
@param len 取得したい文字列の長さを正の整数で指定します。

@return nth が範囲外を指す場合は nil を返します。

//emlist[例][ruby]{
str0 = "bar"
str0[2, 1] #=> "r"
str0[2, 0] #=> ""
str0[2, 100] #=> "r" (右側を超えても...

String#[](substr) -> String | nil (24364.0)

2.1.0

インスタンスメソッド

self が substr を含む場合、一致した文字列を新しく作って返します。 substr を含まなければ nil を返します。

self が substr を含む場合、一致した文字列を新しく作って返します。
substr を含まなければ nil を返します。

@param substr 取得したい文字列のパターン。文字列

//emlist[例][ruby]{
substr = "bar"
result = "foobar"[substr]
p result # => "bar"
p substr.equal?(result) # => false
//}

絞り込み条件を変える

String#slice(nth, len) -> String | nil (24364.0)

2.1.0

インスタンスメソッド

nth 文字目から長さ len 文字の部分文字列を新しく作って返します。 nth が負の場合は文字列の末尾から数えます。

String#slice(substr) -> String | nil (24364.0)

2.1.0

インスタンスメソッド

self が substr を含む場合、一致した文字列を新しく作って返します。 substr を含まなければ nil を返します。

ENV.each {|key, value| ... } -> self (24361.0)

2.1.0

特異メソッド

key と value を引数としてブロックを評価します。

key と value を引数としてブロックを評価します。

//emlist[][ruby]{
ENV['FOO'] = 'bar'
ENV.each do |key, value|
p "value is #{value}" if key == 'FOO' # => "value is bar"
end
# => ENV
//}

ENV.each_pair {|key, value| ... } -> self (24361.0)

2.1.0

特異メソッド

key と value を引数としてブロックを評価します。

Array#count {|obj| ... } -> Integer (24358.0)

2.1.0

インスタンスメソッド

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

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

引数を指定しない場合は、配列の要素数を返します。

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

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

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

//emlist[例][ruby]{
ary = [1, 2, 4, 2.0]
ary.count # => 4
ary.count(2) # => 2
ary.count{|x|x%2==0} ...

絞り込み条件を変える

ENV.each_key {|key| ... } -> self (24358.0)

2.1.0

特異メソッド

key を引数としてブロックを評価します。

key を引数としてブロックを評価します。

//emlist[][ruby]{
ENV['FOO'] = 'bar'
ENV.each_key do |key|
p "key #{key} detected" if key == 'FOO'
end
# "key FOO detected"
//}

ENV.reject {|key, value| ... } -> Hash (24358.0)

2.1.0

特異メソッド

環境変数のうち、ブロックを評価した値が真であるものをとり除きます。 Enumerable#reject と異なり Hash を返します。また、とり除いた結果は実際の環境変数に影響を与えません。

環境変数のうち、ブロックを評価した値が真であるものをとり除きます。
Enumerable#reject と異なり Hash を返します。また、とり除いた結果
は実際の環境変数に影響を与えません。

//emlist[][ruby]{
ENV['TEST'] = 'foo'
result = ENV.reject { |key, value| key == 'TEST' }
result['TEST'] # => nil
ENV['TEST'] # => "foo"
//}

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

2.1.0

インスタンスメソッド

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

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

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

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

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

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

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

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

2.1.0

インスタンスメソッド

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

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

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

自身に要素が存在しない場合は true を返します。

//emlist[例][ruby]{
require 'set'
Set['ant', 'bear', 'cat'].none? {|word| word.length == 5} # => true
Set['ant', 'bear...

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

2.1.0

インスタンスメソッド

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

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

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

//emlist[例][ruby]{
require 'set'
Set['ant', 'bear', 'cat'].one? {|word| word.length == 4} # => true
Set['ant', 'bear', 'cat'].one? {|wo...

絞り込み条件を変える

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

2.1.0

インスタンスメソッド

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

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

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

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

Enumerable#sort は安定ではありません (unstable sort)。
安定なソートが必要な場合は Enumerable#sort_b...

Array#find_index {|item| ...} -> Integer | nil (24355.0)

2.1.0

インスタンスメソッド

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

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

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

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

//emlist[例][ruby]{
p [1, 0, 0, 1, 0].index(1) #=> 0
p [1, 0, 0, 0, 0].index(1) #=> 0
p [0, 0, 0, 0, 0].index(1) #=> nil
//}

ブロックが与えられた場合には、各要素を引数として順にブロックを実行し、
ブロックが真を返した最初...

Array#find_index(val) -> Integer | nil (24355.0)

2.1.0

インスタンスメソッド

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

Array#index {|item| ...} -> Integer | nil (24355.0)

2.1.0

インスタンスメソッド

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

Array#index(val) -> Integer | nil (24355.0)

2.1.0

インスタンスメソッド

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

絞り込み条件を変える

Array#assoc(key) -> Array | nil (24352.0)

2.1.0

インスタンスメソッド

配列の配列を検索して、その 0 番目の要素が key に == で等しい最初の要素を返します。該当する要素がなければ nil を返します。

配列の配列を検索して、その 0 番目の要素が key に == で等しい
最初の要素を返します。該当する要素がなければ nil を返します。

@param key 検索するオブジェクトを指定します。

//emlist[例][ruby]{
ary = [[1,15], [2,25], [3,35]]
p ary.assoc(2) # => [2, 25]
p ary.assoc(100) # => nil
p ary.assoc(15) # => nil
//}

@see Array#rassoc

Array#delete(val) -> object | nil (24352.0)

2.1.0

インスタンスメソッド

指定された val と == で等しい要素を自身からすべて取り除きます。等しい要素が見つかった場合は最後に見つかった要素を、そうでない場合には nil を返します。

指定された val と == で等しい要素を自身からすべて取り除きます。
等しい要素が見つかった場合は最後に見つかった要素を、
そうでない場合には nil を返します。

ブロックが与えられた場合、val と等しい要素が見つからなかったときにブロッ
クを評価してその結果を返します。

@param val 自身から削除したい値を指定します。

//emlist[例][ruby]{
array = [1, 2, 3, 2, 1]
p array.delete(2) #=> 2
p array #=> [1, 3, 1]

# ブロックなしの引数に n...

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

2.1.0

インスタンスメソッド

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

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

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

@param template 自身のバイナリとしてパックするためのテンプレートを文字列で指定します。

以下にあげるものは、Array#pack、String#unpack
のテンプレート文字の一覧です。テンプレート文字は後に「長さ」を表す数字
を続けることができま...

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

2.1.0

インスタンスメソッド

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

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

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

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

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

Array#reject {|item| ... } -> [object] (24340.0)

2.1.0

インスタンスメソッド

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

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

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

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

@see Array#select, Enumerable#reject

絞り込み条件を変える

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

2.1.0

インスタンスメソッド

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

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

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

//emlist[例][ruby]{
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0].partition {|i| i % 3 == 0 }
#=> [[9, 6, 3, 0], [10, 8, 7, 5, 4, 2, 1]]
//}

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

2.1.0

インスタンスメソッド

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

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

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

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

@see Enumerable#select, Array#reject
@see Enumerable#grep_v

Enumerable#max -> object | nil (24328.0)

2.1.0

インスタンスメソッド

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

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

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

@param n 取得する要素数。

//emlist[例][ruby]{
a = %w(albatross dog horse)
a.max # => "horse"
a.max(2) # =>...

Enumerable#min -> object | nil (24328.0)

2.1.0

インスタンスメソッド

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

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

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

@param n 取得する要素数。

//emlist[例][ruby]{
a = %w(albatross dog horse)
a.min # => "albatross"
a.min(2) ...

Array#rassoc(obj) -> Array | nil (24322.0)

2.1.0

インスタンスメソッド

自身が配列の配列であると仮定して、要素の配列でインデックス 1 の要素が obj に等しいものを検索し見つかった最初の要素を返します。該当する要素がなければ nil を返します。

自身が配列の配列であると仮定して、要素の配列でインデックス
1 の要素が obj に等しいものを検索し見つかった最初の要素を返
します。該当する要素がなければ nil を返します。

比較は == 演算子を使って行われます。

@param obj 検索するオブジェクトを指定します。

//emlist[例][ruby]{
a = [[15,1], [25,2], [35,3]]
p a.rassoc(2) # => [25, 2]
//}

@see Array#assoc

絞り込み条件を変える

Hash#assoc(key) -> Array | nil (24322.0)

2.1.0

インスタンスメソッド

ハッシュが key をキーとして持つとき、見つかった要素のキーと値のペアを配列として返します。

ハッシュが key をキーとして持つとき、見つかった要素のキーと値のペア
を配列として返します。

キーの同一性判定には eql? メソッドではなく == メソッドを使います。
key が見つからなかった場合は、nil を返します。

@param key 検索するキー

//emlist[例][ruby]{
h = {"colors" => ["red", "blue", "green"],
"letters" => ["a", "b", "c" ]}
h.assoc("letters") #=> ["letters", ["a", "b", "c"]]
h.assoc("f...

Hash#rassoc(value) -> Array | nil (24322.0)

2.1.0

インスタンスメソッド

ハッシュ内を検索して，引数 value と一致する値を探します。

ハッシュ内を検索して，引数 value と一致する値を探します。

比較は == メソッドを使用して行われます。一致する値があれば，
該当するキーとその値とを要素とするサイズ 2 の配列を返します。
ない場合には nil を返します。

@param value 探索する値。

//emlist[例][ruby]{
a = {1=> "one", 2 => "two", 3 => "three", "ii" => "two"}
a.rassoc("two") #=> [2, "two"]
a.rassoc("four") #=> nil
//}

@see Hash#assoc,...

Hash#to_h -> self | Hash (24322.0)

2.1.0

インスタンスメソッド

self を返します。Hash クラスのサブクラスから呼び出した場合は self を Hash オブジェクトに変換します。

self を返します。Hash クラスのサブクラスから呼び出した場合は
self を Hash オブジェクトに変換します。

//emlist[例][ruby]{
hash = {}
p hash.to_h # => {}
p hash.to_h == hash # => true

class MyHash < Hash;end
my_hash = MyHash.new
p my_hash.to_h # => {}
p my_hash.class # => MyHash
p my_hash.to_h.class # => Hash
//}

Range#max -> object | nil (24319.0)

2.1.0

インスタンスメソッド

範囲内の最大の値を返します。

範囲内の最大の値を返します。

//emlist[例][ruby]{
(1..5).max # => 5
//}

始端が終端より大きい場合、もしくは、終端を含まない範囲オブジェクトの始端が終端と
等しい場合は nil を返します。

//emlist[例][ruby]{
(2..1).max # => nil
(1...1).max # => nil
//}

Range#min -> object | nil (24319.0)

2.1.0

インスタンスメソッド

範囲内の最小の値を返します。

範囲内の最小の値を返します。

//emlist[例][ruby]{
(1..5).min # => 1
//}

始端が終端より大きい場合、もしくは、終端を含まない範囲オブジェクトの始端が終端と
等しい場合は nil を返します。

//emlist[例][ruby]{
(2..1).min # => nil
(1...1).min # => nil
//}

絞り込み条件を変える

String#[](range) -> String (24274.0)

2.1.0

インスタンスメソッド

rangeで指定したインデックスの範囲に含まれる部分文字列を返します。

rangeで指定したインデックスの範囲に含まれる部分文字列を返します。

@param range 取得したい文字列の範囲を示す Range オブジェクト

=== rangeオブジェクトが終端を含む場合

インデックスと文字列の対応については以下の対照図も参照してください。

0 1 2 3 4 5 (インデックス)
-6 -5 -4 -3 -2 -1 (負のインデックス)
| a | b | c | d | e | f |
|<--------->| 'abcdef'[0..2] # => '...

String#slice(range) -> String (24274.0)

2.1.0

インスタンスメソッド

rangeで指定したインデックスの範囲に含まれる部分文字列を返します。

Hash#keep_if -> Enumerator (24208.0)

2.1.0

インスタンスメソッド

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

Hash#select! -> Enumerator (24208.0)

2.1.0

インスタンスメソッド

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

ENV.delete_if -> Enumerator (24154.0)

2.1.0

特異メソッド

key と value を引数としてブロックを評価した値が真である時、環境変数を削除します。

絞り込み条件を変える

ENV.reject! -> Enumerator (24154.0)

2.1.0

特異メソッド

key と value を引数としてブロックを評価した値が真である時、環境変数を削除します。

Enumerable#find_index -> Enumerator (24136.0)

2.1.0

インスタンスメソッド

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

Enumerator::Lazy (24127.0)

2.1.0

クラス

map や select などのメソッドの遅延評価版を提供するためのクラス。

map や select などのメソッドの遅延評価版を提供するためのクラス。

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

* map/collect
* flat_map/collect_concat
* select/find_all
* reject
* grep
* take, take_while
* drop, drop_while
* slice_before, slice_after, slice_when
* chunk
* zip ...

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

2.1.0

インスタンスメソッド

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

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

2.1.0

インスタンスメソッド

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

絞り込み条件を変える

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

2.1.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#find_all -> Enumerator (24097.0)

2.1.0

インスタンスメソッド

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

Enumerable#select -> Enumerator (24097.0)

2.1.0

インスタンスメソッド

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

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

2.1.0

インスタンスメソッド

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

RubyVM::InstructionSequence.disasm(body) -> String (24091.0)

2.1.0

特異メソッド

引数 body で指定したオブジェクトから作成した RubyVM::InstructionSequence オブジェクトを人間が読める形式の文字列に変換して返します。

引数 body で指定したオブジェクトから作成した
RubyVM::InstructionSequence オブジェクトを人間が読める形式の文字
列に変換して返します。

@param body Proc、Method オブジェクトを指定します。

例1:Proc オブジェクトを指定した場合

# /tmp/proc.rb
p = proc { num = 1 + 2 }
puts RubyVM::InstructionSequence.disasm(p)

出力:

== disasm: <RubyVM::InstructionSequence:block in <main...

絞り込み条件を変える

RubyVM::InstructionSequence.disassemble(body) -> String (24091.0)

2.1.0

特異メソッド

引数 body で指定したオブジェクトから作成した RubyVM::InstructionSequence オブジェクトを人間が読める形式の文字列に変換して返します。

Array#delete_if -> Enumerator (24082.0)

2.1.0

インスタンスメソッド

Array#reject! -> Enumerator (24082.0)

2.1.0

インスタンスメソッド

ARGF.class#each(rs = $/) -> Enumerator (24079.0)

2.1.0

インスタンスメソッド

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

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

2.1.0

インスタンスメソッド

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

絞り込み条件を変える

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

2.1.0

インスタンスメソッド

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

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

2.1.0

インスタンスメソッド

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

Array#rindex -> Enumerator (24076.0)

2.1.0

インスタンスメソッド

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

File#lstat -> File::Stat (24073.0)

2.1.0

インスタンスメソッド

ファイルの状態を含む File::Stat オブジェクトを生成して返します。シンボリックリンクに関してリンクそのものの情報を返します。 lstat(2) を実装していないシステムでは、IO#statと同じです。

ファイルの状態を含む File::Stat オブジェクトを生成して返します。
シンボリックリンクに関してリンクそのものの情報を返します。
lstat(2) を実装していないシステムでは、IO#statと同じです。

@raise Errno::EXXX 失敗した場合に発生します。

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

//emlist[例][ruby]{
# testlink は testfile のシンボリックリンク
File.open("testlink") do |f|
p f.lstat == File.stat("testfil...

Numeric#remainder(other) -> Numeric (24073.0)

2.1.0

インスタンスメソッド

self を other で割った余り r を返します。

self を other で割った余り r を返します。

ここで、商 q と余り r は、

* self == other * q + r
と

* self > 0 のとき 0 <= r < |other|
* self < 0 のとき -|other| < r <= 0
* q は整数

をみたす数です。r の符号は self と同じになります。
商 q を直接返すメソッドはありません。self.quo(other).truncate がそれに相当します。

@param other 自身を割る数を指定します。

//emlist[例][ruby]{
p 13....

絞り込み条件を変える

<< 1 2 > >>

別のキーワード

種類

ライブラリ

クラス

モジュール

オブジェクト

キーワード

検索結果

先頭5件

Symbol#==(other) -> true | false (78640.0)

Exception#==(other) -> bool (78511.0)

FalseClass#|(other) -> bool (78463.0)

TrueClass#|(other) -> bool (78463.0)

Proc#===(*arg) -> () (60655.0)

Proc#[](*arg) -> () (42055.0)

Proc#call(*arg) -> () (42055.0)

Proc#yield(*arg) -> () (42055.0)

Numeric (25639.0)

Hash#keep_if {|key, value| ... } -> self (24508.0)

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

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

ENV.delete_if {|key, value| ... } -> ENV (24454.0)

ENV.reject! {|key, value| ... } -> ENV | nil (24454.0)

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

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

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

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

Enumerator.new(size=nil) {|y| ... } -> Enumerator (24415.0)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ARGF.class#each(rs = $/) { |line| ... } -> self (24379.0)

ARGF.class#each(rs = $/, limit) { |line| ... } -> self (24379.0)

ARGF.class#each_line(rs = $/) { |line| ... } -> self (24379.0)

ARGF.class#each_line(rs = $/, limit) { |line| ... } -> self (24379.0)

String#[](nth) -> String | nil (24379.0)

String#slice(nth) -> String | nil (24379.0)

Array#rindex {|item| ... } -> Integer | nil (24376.0)

Array#rindex(val) -> Integer | nil (24376.0)

Range#max {|a, b| ... } -> object | nil (24364.0)

Range#min {|a, b| ... } -> object | nil (24364.0)

String#[](nth, len) -> String | nil (24364.0)

String#[](substr) -> String | nil (24364.0)

String#slice(nth, len) -> String | nil (24364.0)

String#slice(substr) -> String | nil (24364.0)

ENV.each {|key, value| ... } -> self (24361.0)

ENV.each_pair {|key, value| ... } -> self (24361.0)

Array#count {|obj| ... } -> Integer (24358.0)

ENV.each_key {|key| ... } -> self (24358.0)

ENV.reject {|key, value| ... } -> Hash (24358.0)

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

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

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

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

Array#find_index {|item| ...} -> Integer | nil (24355.0)

Array#find_index(val) -> Integer | nil (24355.0)

Array#index {|item| ...} -> Integer | nil (24355.0)

Array#index(val) -> Integer | nil (24355.0)

Array#assoc(key) -> Array | nil (24352.0)

Array#delete(val) -> object | nil (24352.0)

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

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

Array#reject {|item| ... } -> [object] (24340.0)

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

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

Enumerable#max -> object | nil (24328.0)

Enumerable#min -> object | nil (24328.0)

Array#rassoc(obj) -> Array | nil (24322.0)

Hash#assoc(key) -> Array | nil (24322.0)