バージョン:2.3.0 > 種類:インスタンスメソッド > クエリ:l > クエリ:hash > ライブラリ:ビルトイン

92件ヒット [1-92件を表示] （0.073秒）

トップページ >

:2.3.0

:インスタンスメソッド

:hash

:ビルトイン

別のキーワード

クラス

Array (1)
Encoding::Converter (4)
Float (1)
Hash (68)
Numeric (1)
Object (3)
Rational (1)
String (8)
Struct (1)
UnboundMethod (1)

モジュール

Enumerable (3)

キーワード

< (1)
<= (1)
== (1)
=== (1)
> (1)
>= (1)
[] (1)
[]= (1)
assoc (1)
clear (1)
clone (1)
compare_by_identity (1)
compare_by_identity? (1)
default (2)
default= (1)
default_proc (1)
default_proc= (1)
delete (2)
delete_if (2)
dig (3)
dup (1)
each (1)
each_key (1)
each_pair (1)
each_value (2)
empty? (1)
eql? (4)
equal? (1)
fetch (1)
fetch_values (2)
flatten (1)
group_by (2)
gsub (1)
gsub! (3)
has_key? (1)
has_value? (1)
include? (1)
index (1)
is_a? (1)
keep_if (1)
key (1)
key? (1)
kind_of? (1)
length (1)
member? (1)
merge (1)
merge! (2)
owner (1)
primitive_convert (4)
rassoc (1)
rehash (1)
reject (1)
reject! (2)
replace (1)
select (2)
select! (2)
shift (1)
size (1)
store (1)
sub (1)
sub! (2)
to_h (2)
to_hash (1)
update (2)
value? (1)
values (1)
values_at (1)

検索結果

Float#hash -> Integer (63367.0)

2.3.0

インスタンスメソッド

ハッシュ値を返します。

ハッシュ値を返します。

//emlist[例][ruby]{
pi1 = 3.14
pi2 = 3.14
pi3 = 3.1415

pi1.hash # => 335364239
pi2.hash # => 335364239
pi3.hash # => 420540030
//}

Rational#hash -> Integer (63331.0)

2.3.0

インスタンスメソッド

自身のハッシュ値を返します。

自身のハッシュ値を返します。

@return ハッシュ値を返します。

@see Object#hash

Hash#to_hash -> self (45757.0)

2.3.0

インスタンスメソッド

self を返します。

self を返します。

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

@see Object#to_hash, Hash#to_h

Hash#select {|key, value| ... } -> Hash (45649.0)

2.3.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#each_value {|value| ... } -> self (45646.0)

2.3.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#rehash -> self (45646.0)

2.3.0

インスタンスメソッド

キーのハッシュ値を再計算します。

キーのハッシュ値を再計算します。

キーになっているオブジェクトの内容が変化した時など、
ハッシュ値が変わってしまった場合はこのメソッドを使ってハッシュ値を再計算しない
限り、そのキーに対応する値を取り出すことができなくなります。

@raise RuntimeError Hash#eachなどのイテレータの評価途中でrehashすると発生します。
@return selfを返します。

//emlist[例][ruby]{
a = [ "a", "b" ]
h = { a => 100 }

p h[a] #=> 100

a[0] = "z"
p h[a] #=>...

Hash#has_value?(value) -> bool (45628.0)

2.3.0

インスタンスメソッド

ハッシュが value を値として持つ時真を返します。値の一致判定は == で行われます。

ハッシュが value を値として持つ時真を返します。
値の一致判定は == で行われます。

@param value 探索する値を指定します。

//emlist[][ruby]{
p({1 => "one"}.value?("one")) #=> true
p({1 => "one"}.value?("two")) #=> false
//}

@see Hash#key?

Hash#value?(value) -> bool (45628.0)

2.3.0

インスタンスメソッド

ハッシュが value を値として持つ時真を返します。値の一致判定は == で行われます。

Hash#clone -> Hash (45616.0)

2.3.0

インスタンスメソッド

selfと同じ内容を持つ新しいハッシュを返します。

selfと同じ内容を持つ新しいハッシュを返します。

clone は frozen singleton-class の情報も含めてコピーしますが、
dup は内容と tainted だけをコピーします。
またどちらのメソッドも要素それ自体のコピーはしません。
つまり参照しているオブジェクトが変わらない「浅い(shallow)」コピーを行います。

//emlist[例][ruby]{
h1 = {"have" => "have a","as" => "as a" }
h2 = h1.dup

h2["have"] = "has"
p h2 #=> {"have"=>"has", "as"=>...

Hash#default -> object | nil (45454.0)

2.3.0

インスタンスメソッド

ハッシュのデフォルト値を返します。

ハッシュのデフォルト値を返します。

ハッシュのデフォルト値がブロックで与えられている場合、 1 番目の形式だと
返り値が nil になることに注意してください。この場合、ハッシュのデフォルト値に
ついて調べるには 2 番目の形式か Hash#default_proc を使ってください。

2 番目の形式はハッシュがデフォルト値としてブロックを持つ場合に、
self と引数 key をブロックに渡して評価し、その結果を返します。

@param key デフォルトのブロックにキーとして渡されます。

//emlist[例][ruby]{
h = Hash.new("default")
p h....

絞り込み条件を変える

Hash#default(key) -> object | nil (45454.0)

2.3.0

インスタンスメソッド

ハッシュのデフォルト値を返します。

Hash#replace(other) -> self (45454.0)

2.3.0

インスタンスメソッド

ハッシュの内容を other の内容で置き換えます。

ハッシュの内容を other の内容で置き換えます。

デフォルト値の設定もotherの内容になります。
otherがハッシュではない場合、otherのメソッドto_hashを使って暗黙の変換を試みます。

self = other.to_hash.dup と同じです。

@param other ハッシュまたはメソッド to_hash でハッシュに変換できるオブジェクトです。
@return self を返します。

//emlist[例][ruby]{
foo = {1 => 'a', 2 => 'b'}
bar = {2 => 'B', 3 => 'C'}

foo.replace(b...

Hash#default_proc=(pr) (45436.0)

2.3.0

インスタンスメソッド

ハッシュのデフォルト値を返す Proc オブジェクトを変更します。

ハッシュのデフォルト値を返す Proc オブジェクトを
変更します。

以前のデフォルトは値(Hash#default)の場合も
Proc の場合(Hash#default_proc)でも上書きされます。

引数には to_proc で Proc オブジェクトに変換できる
オブジェクトも受け付けます。

nil を指定した場合は現在の Hash#default_proc をクリアします。

@param pr デフォルト値を返す手続きオブジェクト

//emlist[例][ruby]{
h = {}
h.default_proc = proc do |hash, key|
hash[ke...

Hash#default_proc -> Proc | nil (45400.0)

2.3.0

インスタンスメソッド

ハッシュのデフォルト値を返す Proc オブジェクトを返します。ハッシュがブロック形式のデフォルト値を持たない場合 nil を返します。

ハッシュのデフォルト値を返す Proc オブジェクトを返します。
ハッシュがブロック形式のデフォルト値を持たない場合 nil を返します。

//emlist[例][ruby]{
h = Hash.new {|hash, key| "The #{key} not exist in #{hash.inspect}"}
p h.default #=> nil
p block = h.default_proc #=> #<Proc:0x0x401a9ff4>
p block.call({},:foo) #=> "The foo not exist in {}"

h...

Hash#delete_if -> Enumerator (45382.0)

2.3.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#delete_if {|key, value| ... } -> self (45382.0)

2.3.0

インスタンスメソッド

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

Hash#values_at(*keys) -> [object] (45382.0)

2.3.0

インスタンスメソッド

引数で指定されたキーに対応する値の配列を返します。

引数で指定されたキーに対応する値の配列を返します。

キーに対応する要素がなければデフォルト値が使用されます。

@param keys キーを 0 個以上指定します。

@return 引数で指定されたキーに対応する値の配列を返します。
引数が指定されなかった場合は、空の配列を返します。

//emlist[例][ruby]{
h = {1=>"a", 2=>"b", 3=>"c"}

p h.values_at(1,3,4) #=> ["a", "c", nil]
# [h[1], h[3] ,h[4]] と同じ
//}

@see Hash#...

Hash#select -> Enumerator (45349.0)

2.3.0

インスタンスメソッド

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

Hash#each_value -> Enumerator (45346.0)

2.3.0

インスタンスメソッド

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

Hash#equal?(other) -> bool (45346.0)

2.3.0

インスタンスメソッド

指定された other が self 自身である場合のみ真を返します。

指定された other が self 自身である場合のみ真を返します。

@param other 自身と比較したい Hash オブジェクトを指定します。

//emlist[例][ruby]{
p({}.equal?({})) #=> false
a = {}
p a.equal?(a) #=> true
//}

@see Hash#==

絞り込み条件を変える

Hash#fetch_values(key, ...) -> [object] (45346.0)

2.3.0

インスタンスメソッド

引数で指定されたキーに関連づけられた値の配列を返します。

引数で指定されたキーに関連づけられた値の配列を返します。

該当するキーが登録されていない時には、ブロックが与えられていればそのブ
ロックを評価した値を返します。ブロックが与えられていない時は
KeyError が発生します。

self にデフォルト値が設定されていても無視されます（挙動に変化がありません）。

@param key 探索するキーを任意個指定します。

@raise KeyError ブロックが与えられてない時にキーの探索に失敗すると発生します。

//emlist[例][ruby]{
h = { "cat" => "feline", "dog" => "canine", ...

Hash#fetch_values(key, ...) { |key| ... } -> [object] (45346.0)

2.3.0

インスタンスメソッド

引数で指定されたキーに関連づけられた値の配列を返します。

Hash#values -> [object] (45346.0)

2.3.0

インスタンスメソッド

ハッシュの全値の配列を返します。

ハッシュの全値の配列を返します。

//emlist[例][ruby]{
h1 = { "a" => 100, 2 => ["some"], :c => "c" }
p h1.values #=> [100, ["some"], "c"]
//}

@see Hash#keys,Hash#to_a

Hash#clear -> self (45328.0)

2.3.0

インスタンスメソッド

ハッシュの中身を空にします。

ハッシュの中身を空にします。

空にした後のselfを返します。
デフォルト値の設定はクリアされません。

//emlist[例][ruby]{
h = Hash.new("default value")
h[:some] = "some"
p h #=> {:some=>"some"}

h.clear

p h #=> {}
p h.default #=> "default value"
//}

Hash#default=(value) (45328.0)

2.3.0

インスタンスメソッド

ハッシュのデフォルト値を value に変更します。対応する値が存在しないキーで検索した時にはこの値を返すようになります。

ハッシュのデフォルト値を value に変更します。対応する値が存
在しないキーで検索した時にはこの値を返すようになります。

デフォルト値（ブロックを含む）が既に設定してあった場合も value で上書きします。

@param value 設定するデフォルト値です。
@return value を返します。

//emlist[例][ruby]{
h = {}
p h.default #=>nil

h.default = "default"
p h.default #=>"default"
//}

@see Hash#default

絞り込み条件を変える

Hash#delete(key) -> object | nil (45328.0)

2.3.0

インスタンスメソッド

key に対応する要素を取り除きます。

key に対応する要素を取り除きます。

@param key 取り除くキーを指定します。

@return 取り除かれた要素の値を返します。
key に対応する要素が存在しない時には nil を返します。

与えられたブロックは key にマッチする要素がなかった時に評価され、その結果を返します。

//emlist[例][ruby]{
h = {:ab => "some" , :cd => "all"}

p h.delete(:ab) #=> "some"
p h.delete(:ef) #=> nil
p h.delete(:ef){|key|"#{k...

Hash#delete(key) {|key| ... } -> object (45328.0)

2.3.0

インスタンスメソッド

key に対応する要素を取り除きます。

Hash#flatten(level = 1) -> Array (45310.0)

2.3.0

インスタンスメソッド

自身を平坦化した配列を生成して返します。

自身を平坦化した配列を生成して返します。

全てのキーと値を新しい配列の要素として展開します。
Array#flatten と違って、デフォルトではこのメソッドは自身を
再帰的に平坦化しません。level を指定すると指定されたレベルまで
再帰的に平坦化します。

@param level 展開するレベル

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

Hash#length -> Integer (45310.0)

2.3.0

インスタンスメソッド

ハッシュの要素の数を返します。

ハッシュの要素の数を返します。

//emlist[][ruby]{
h = { "d" => 100, "a" => 200, "v" => 300, "e" => 400 }
h.length #=> 4
h.size #=> 4
h.delete("a") #=> 200
h.length #=> 3
h.size #=> 3
//}

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

2.3.0

インスタンスメソッド

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

絞り込み条件を変える

Hash#select! -> Enumerator (36364.0)

2.3.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 (36364.0)

2.3.0

インスタンスメソッド

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

Hash#eql?(other) -> bool (36346.0)

2.3.0

インスタンスメソッド

自身と other が同じ数のキーを保持し、キーが eql? メソッドで比較して全て等しく、値が == メソッドで比較して全て等しい場合に真を返します。

自身と other が同じ数のキーを保持し、キーが eql? メソッドで比較して全て等しく、
値が == メソッドで比較して全て等しい場合に真を返します。

@param other 自身と比較したい Hash オブジェクトを指定します。

//emlist[例][ruby]{
#(出力関数は省略)
{ 1 => :a } == { 1 => :a } #=> true
{ 1 => :a } == { 1 => :a, 2 => :b } #=> false
{ 1 => :a } == { 1.0 => :a } #=> fa...

Hash#include?(key) -> bool (36328.0)

2.3.0

インスタンスメソッド

ハッシュが key をキーとして持つ時真を返します。

ハッシュが key をキーとして持つ時真を返します。

@param key 探索するキーを指定します。

//emlist[][ruby]{
p({1 => "one"}.key?(1)) # => true
p({1 => "one"}.key?(2)) # => false
//}

@see Hash#value?

Hash#dup -> Hash (36316.0)

2.3.0

インスタンスメソッド

selfと同じ内容を持つ新しいハッシュを返します。

絞り込み条件を変える

Hash#reject! -> Enumerator (36082.0)

2.3.0

インスタンスメソッド

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

Hash#size -> Integer (36010.0)

2.3.0

インスタンスメソッド

ハッシュの要素の数を返します。

Hash#to_h -> self | Hash (27889.0)

2.3.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
//}

Hash#merge(other) {|key, self_val, other_val| ... } -> Hash (27706.0)

2.3.0

インスタンスメソッド

selfとotherのハッシュの内容をマージ(統合)した結果を返します。デフォルト値はselfの設定のままです。

selfとotherのハッシュの内容をマージ(統合)した結果を返します。デフォルト値はselfの設定のままです。

self と other に同じキーがあった場合はブロック付きか否かで
判定方法が違います。ブロック付きのときはブロックを呼び出して
その返す値を重複キーに対応する値にします。ブロック付きでない
場合は常に other の値を使います。

otherがハッシュではない場合、otherのメソッドto_hashを使って暗黙の変換を試みます。

@param other マージ用のハッシュまたはメソッド to_hash でハッシュに変換できるオブジェクトです。
@return マージ...

Hash#reject {|key, value| ... } -> Hash (27685.0)

2.3.0

インスタンスメソッド

self を複製して、ブロックを評価した値が真になる要素を削除したハッシュを返します。

self を複製して、ブロックを評価した値が真になる要
素を削除したハッシュを返します。

ハッシュを返すことを除けば
Enumerable#reject とほぼ同じです。
selfを破壊的に変更したい場合はかわりにHash#delete_ifかHash#reject!を使います。

//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=>"2"}
//}

@see Hash#delete_if,...

絞り込み条件を変える

Hash#merge!(other) {|key, self_val, other_val| ... } -> self (27664.0)

2.3.0

インスタンスメソッド

selfとotherのハッシュの内容をマージ(統合)します。

selfとotherのハッシュの内容をマージ(統合)します。

デフォルト値はselfの設定のままです。

self と other に同じキーがあった場合はブロック付きか否かで
判定方法が違います。ブロック付きのときはブロックを呼び出して
その返す値を重複キーに対応する値にします。ブロック付きでない
場合は常に other の値を使います。

otherがハッシュではない場合、otherのメソッドto_hashを使って暗黙の変換を試みます。

@param other マージ用のハッシュまたはメソッド to_hash でハッシュに変換できるオブジェクトです。
@return マージ後のse...

Hash#update(other) {|key, self_val, other_val| ... } -> self (27664.0)

2.3.0

インスタンスメソッド

selfとotherのハッシュの内容をマージ(統合)します。

Hash#[](key) -> object | nil (27490.0)

2.3.0

インスタンスメソッド

key に関連づけられた値を返します。

key に関連づけられた値を返します。

該当するキーが登録されていない時には、デフォルト値を返します。

デフォルト値と値としての nil を区別する必要が
ある場合は Hash#fetch または Hash#key? を使ってください。

@param key 探索するキーを指定します。

//emlist[例][ruby]{
h = {:ab => "some" , :cd => "all"}
p h[:ab] #=> "some"
p h[:ef] #=> nil

h1 = Hash.new("default value")
p h1[...

Hash#<(other) -> bool (27382.0)

2.3.0

インスタンスメソッド

self が other のサブセットである場合に真を返します。

self が other のサブセットである場合に真を返します。

@param other 自身と比較したい Hash オブジェクトを指定します。

//emlist[例][ruby]{
h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 < h2 # => true
h2 < h1 # => false
h1 < h1 # => false
//}

@see Hash#<=, Hash#>=, Hash#>

Hash#<=(other) -> bool (27382.0)

2.3.0

インスタンスメソッド

self が other のサブセットか同じである場合に真を返します。

self が other のサブセットか同じである場合に真を返します。

@param other 自身と比較したい Hash オブジェクトを指定します。

//emlist[例][ruby]{
h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 <= h2 # => true
h2 <= h1 # => false
h1 <= h1 # => true
//}

@see Hash#<, Hash#>=, Hash#>

絞り込み条件を変える

Hash#>(other) -> bool (27382.0)

2.3.0

インスタンスメソッド

other が self のサブセットである場合に真を返します。

other が self のサブセットである場合に真を返します。

@param other 自身と比較したい Hash オブジェクトを指定します。

//emlist[例][ruby]{
h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 > h2 # => false
h2 > h1 # => true
h1 > h1 # => false
//}

@see Hash#<=, Hash#<, Hash#>=

Hash#>=(other) -> bool (27382.0)

2.3.0

インスタンスメソッド

other が self のサブセットか同じである場合に真を返します。

other が self のサブセットか同じである場合に真を返します。

@param other 自身と比較したい Hash オブジェクトを指定します。

//emlist[例][ruby]{
h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 >= h2 # => false
h2 >= h1 # => true
h1 >= h1 # => true
//}

@see Hash#<=, Hash#<, Hash#>

Hash#shift -> [object, object] | nil (27382.0)

2.3.0

インスタンスメソッド

ハッシュからキーが追加された順で先頭の要素をひとつ取り除き、 [key, value]という配列として返します。

ハッシュからキーが追加された順で先頭の要素をひとつ取り除き、
[key, value]という配列として返します。

shiftは破壊的メソッドです。selfは要素を取り除かれた残りのハッシュに変更されます。

ハッシュが空の場合、デフォルト値（Hash#defaultまたはHash#default_procのブロックの値か、どちらもnilならばnil）
を返します(このとき、[key,value] という形式の値を返すわけではないことに注意)。

将来のバージョン(Ruby 3.2を予定)ではデフォルト値に関わらず nil になる予定なので、デフォルト値を設定しているハッシュで
shift ...

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

2.3.0

インスタンスメソッド

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

Hash#merge!(other) -> self (27364.0)

2.3.0

インスタンスメソッド

selfとotherのハッシュの内容をマージ(統合)します。

絞り込み条件を変える

Hash#update(other) -> self (27364.0)

2.3.0

インスタンスメソッド

selfとotherのハッシュの内容をマージ(統合)します。

Hash#==(other) -> bool (27346.0)

2.3.0

インスタンスメソッド

自身と other が同じ数のキーを保持し、キーが eql? メソッドで比較して全て等しく、値が == メソッドで比較して全て等しい場合に真を返します。

Hash#===(other) -> bool (27346.0)

2.3.0

インスタンスメソッド

自身と other が同じ数のキーを保持し、キーが eql? メソッドで比較して全て等しく、値が == メソッドで比較して全て等しい場合に真を返します。

Hash#each {|key, value| ... } -> self (27346.0)

2.3.0

インスタンスメソッド

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

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

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

each_pair は each のエイリアスです。

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

{:a=>1, :b=>2}.each {|k, v| p [k, v]}
#=> [:a, 1]
# [:b, 2]

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

Hash#each_key {|key| ... } -> self (27346.0)

2.3.0

インスタンスメソッド

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

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

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

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

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

@see Hash#each_pair,Hash#each_value

絞り込み条件を変える

Hash#each_pair {|key, value| ... } -> self (27346.0)

2.3.0

インスタンスメソッド

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

Hash#index(val) -> object (27346.0)

2.3.0

インスタンスメソッド

値 val に対応するキーを返します。対応する要素が存在しない時には nil を返します。

値 val に対応するキーを返します。対応する要素が存在しない時には
nil を返します。

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

Hash#index は obsolete です。
使用すると警告メッセージが表示されます。

@param val 探索に用いる値を指定します。

//emlist[例][ruby]{
h = {:ab => "some" , :cd => "all" , :ef => "all"}

p h.key("some") #=> :ab
p h.key("all") #=> :cd
p h.key("at") #=> nil
//}

@...

Hash#key(val) -> object (27346.0)

2.3.0

インスタンスメソッド

値 val に対応するキーを返します。対応する要素が存在しない時には nil を返します。

Hash#[]=(key, value) (27328.0)

2.3.0

インスタンスメソッド

key に対して value を関連づけます。value を返します。

key に対して value を関連づけます。value を返し
ます。

@param key キーを指定します。
@param value 値を指定します。

//emlist[例][ruby]{
h = {}

h[:key] = "value"
p h #=>{:key => "value"}
//}

@see Hash#[]

Hash#compare_by_identity -> self (27328.0)

2.3.0

インスタンスメソッド

ハッシュのキーの一致判定をオブジェクトの同一性で判定するように変更します。

ハッシュのキーの一致判定をオブジェクトの同一性で判定するように変更します。

デフォルトでは、キーのオブジェクトによっては内容が同じならキーが一致しているとみなされますが、より厳密に
Object#object_idが一致しているかどうかを条件とするようにselfを変更します。

selfが変化する破壊的メソッドです。

@return selfを返します。

//emlist[例][ruby]{
h1 = { "a" => 100, "b" => 200, :c => "c" }
p h1.compare_by_identity? #=> false
p h1["a"] #=...

絞り込み条件を変える

Hash#compare_by_identity? -> bool (27328.0)

2.3.0

インスタンスメソッド

ハッシュがキーの一致判定をオブジェクトの同一性を用いて行っているならば真を返します。

ハッシュがキーの一致判定をオブジェクトの同一性を用いて行っているならば真を返します。

//emlist[例][ruby]{
h1 = {}
p h1.compare_by_identity? #=> false

h1.compare_by_identity

p h1.compare_by_identity? #=> true
//}

@see Hash#compare_by_identity

Hash#fetch(key, default) -> object (27328.0)

2.3.0

インスタンスメソッド

key に関連づけられた値を返します。該当するキーが登録されていない時には、引数 default が与えられていればその値を、ブロックが与えられていればそのブロックを評価した値を返します。

key に関連づけられた値を返します。該当するキーが登録されてい
ない時には、引数 default が与えられていればその値を、ブロッ
クが与えられていればそのブロックを評価した値を返します。

fetchはハッシュ自身にデフォルト値が設定されていても単に無視します（挙動に変化がありません）。

@param key 探索するキーを指定します。
@param default 該当するキーが登録されていない時の返り値を指定します。
@raise KeyError 引数defaultもブロックも与えられてない時、キーの探索に失敗すると発生します。

//emlist[例][ruby]{
h...

Hash#has_key?(key) -> bool (27328.0)

2.3.0

インスタンスメソッド

ハッシュが key をキーとして持つ時真を返します。

Hash#key?(key) -> bool (27328.0)

2.3.0

インスタンスメソッド

ハッシュが key をキーとして持つ時真を返します。

Hash#member?(key) -> bool (27328.0)

2.3.0

インスタンスメソッド

ハッシュが key をキーとして持つ時真を返します。

絞り込み条件を変える

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

2.3.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#store(key, value) -> object (27328.0)

2.3.0

インスタンスメソッド

key に対して value を関連づけます。value を返します。

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

2.3.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#dig(key, ...) -> object | nil (27310.0)

2.3.0

インスタンスメソッド

self 以下のネストしたオブジェクトを dig メソッドで再帰的に参照して返します。途中のオブジェクトが nil であった場合は nil を返します。

self 以下のネストしたオブジェクトを dig メソッドで再帰的に参照して返し
ます。途中のオブジェクトが nil であった場合は nil を返します。

@param key キーを任意個指定します。

//emlist[例][ruby]{
h = { foo: {bar: {baz: 1}}}

h.dig(:foo, :bar, :baz) # => 1
h.dig(:foo, :zot, :xyz) # => nil

g = { foo: [10, 11, 12] }
g.dig(:foo, 1) # => 11
//}

@see...

Hash#empty? -> bool (27310.0)

2.3.0

インスタンスメソッド

ハッシュが空の時、真を返します。

ハッシュが空の時、真を返します。

//emlist[例][ruby]{
puts({}.empty?) #=> true
//}

絞り込み条件を変える

Object#eql?(other) -> bool (18394.0)

2.3.0

インスタンスメソッド

オブジェクトと other が等しければ真を返します。Hash で二つのキーが等しいかどうかを判定するのに使われます。

オブジェクトと other が等しければ真を返します。Hash で二つのキー
が等しいかどうかを判定するのに使われます。

このメソッドは各クラスの性質に合わせて再定義すべきです。
多くの場合、 == と同様に同値性の判定をするように再定義されていますが、
適切にキー判定ができるようにより厳しくなっている場合もあります。

デフォルトでは equal? と同じオブジェクト
の同一性判定になっています。

このメソッドを再定義した時には Object#hash メソッ
ドも再定義しなければなりません。

@param other 比較するオブジェクトです。

//emlist[][ruby]{...

String#eql?(other) -> bool (18346.0)

2.3.0

インスタンスメソッド

文字列の内容が文字列 other の内容と等しいときに true を返します。等しくなければ false を返します。

文字列の内容が文字列 other の内容と等しいときに true を返します。
等しくなければ false を返します。

このメソッドは文字列の内容を比較します。
同一のオブジェクトかどうかを比較するわけではありません。
つまり、"string".eql?(str) という式を実行した場合には、
str が "string" という内容の文字列でありさえすれば常に true を返します。
同一のオブジェクトであるかどうかを判定したいときは
Object#equal? を使ってください。

アルファベットの大文字小文字を無視して比較したい場合は、String#upcase,
String#d...

Numeric#eql?(other) -> bool (18328.0)

2.3.0

インスタンスメソッド

自身と other のクラスが等しくかつ == メソッドで比較して等しい場合に true を返します。そうでない場合に false を返します。

自身と other のクラスが等しくかつ == メソッドで比較して等しい場合に true を返します。
そうでない場合に false を返します。

Numeric のサブクラスは、eql? で比較して等しい数値同士が同じハッシュ値を返すように
hash メソッドを適切に定義する必要があります。

@param other 自身と比較したい数値を指定します。

//emlist[例][ruby]{
p 1.eql?(1) #=> true
p 1.eql?(1.0) #=> false
p 1 == 1.0 #=> true
//}

@see Object#equal?, ...

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

2.3.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}
//}

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

2.3.0

インスタンスメソッド

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

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

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

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

絞り込み条件を変える

Enumerable#group_by -> Enumerator (9013.0)

2.3.0

インスタンスメソッド

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

String#gsub!(pattern, hash) -> self | nil (733.0)

2.3.0

インスタンスメソッド

文字列中の pattern にマッチした部分をキーにして hash を引いた値へ破壊的に置き換えます。

文字列中の pattern にマッチした部分をキーにして hash を引いた値へ破壊的に置き換えます。

@param pattern 置き換える文字列のパターン
@param hash 置き換える文字列を与えるハッシュ

//emlist[例][ruby]{
hash = {'b'=>'B', 'c'=>'C'}
str = "abcabc"
str.gsub!(/[bc]/){hash[$&]}
p str #=> "aBCaBC"

str = "abcabc"
str.gsub!(/[bc]/, hash)
p str #=> "aBCaBC"
//...

Array#dig(idx, ...) -> object | nil (328.0)

2.3.0

インスタンスメソッド

self 以下のネストしたオブジェクトを dig メソッドで再帰的に参照して返します。途中のオブジェクトが nil であった場合は nil を返します。

self 以下のネストしたオブジェクトを dig メソッドで再帰的に参照して返し
ます。途中のオブジェクトが nil であった場合は nil を返します。

@param idx インデックスを整数で任意個指定します。

//emlist[例][ruby]{
a = [[1, [2, 3]]]

a.dig(0, 1, 1) # => 3
a.dig(1, 2, 3) # => nil
a.dig(0, 0, 0) # => TypeError: Fixnum does not have #dig...

Encoding::Converter#primitive_convert(source_buffer, destination_buffer) -> Symbol (328.0)

2.3.0

インスタンスメソッド

エンコーディング変換のためのメソッドの中で、もっとも細かな扱いが可能なメソッドです。

エンコーディング変換のためのメソッドの中で、もっとも細かな扱いが可能なメソッドです。

可搬性を確保しつつ、不正なバイトや変換先で未定義な文字の扱いを細かに指定したいときは、Encoding::Converter#primitive_convert が唯一の方法になります。

@param source_buffer 変換元文字列のバッファ
@param destination_buffer 変換先文字列を格納するバッファ
@param destination_byteoffset 変換先バッファでのオフセット
@param destination_bytesize 変換先バッファの容量
@...

Encoding::Converter#primitive_convert(source_buffer, destination_buffer, destination_byteoffset) -> Symbol (328.0)

2.3.0

インスタンスメソッド

エンコーディング変換のためのメソッドの中で、もっとも細かな扱いが可能なメソッドです。

絞り込み条件を変える

Encoding::Converter#primitive_convert(source_buffer, destination_buffer, destination_byteoffset, destination_bytesize) -> Symbol (328.0)

2.3.0

インスタンスメソッド

エンコーディング変換のためのメソッドの中で、もっとも細かな扱いが可能なメソッドです。

Encoding::Converter#primitive_convert(source_buffer, destination_buffer, destination_byteoffset, destination_bytesize, options) -> Symbol (328.0)

2.3.0

インスタンスメソッド

エンコーディング変換のためのメソッドの中で、もっとも細かな扱いが可能なメソッドです。

Object#is_a?(mod) -> bool (328.0)

2.3.0

インスタンスメソッド

オブジェクトが指定されたクラス mod かそのサブクラスのインスタンスであるとき真を返します。

オブジェクトが指定されたクラス mod かそのサブクラスのインスタンスであるとき真を返します。

また、オブジェクトがモジュール mod をインクルードしたクラスかそのサブクラス
のインスタンスである場合にも真を返します。
Module#includeだけではなく、Object#extendやModule#prependに
よってサブクラスのインスタンスになる場合も含みます。
上記のいずれでもない場合に false を返します。

@param mod クラスやモジュールなど、Moduleかそのサブクラスのインスタンスです。

//emlist[][ruby]{
module M
end
c...

Object#kind_of?(mod) -> bool (328.0)

2.3.0

インスタンスメソッド

オブジェクトが指定されたクラス mod かそのサブクラスのインスタンスであるとき真を返します。

String#gsub!(pattern) {|matched| .... } -> self | nil (328.0)

2.3.0

インスタンスメソッド

文字列中で pattern にマッチする部分全てを順番にブロックに渡し、その評価結果に置き換えます。

文字列中で pattern にマッチする部分全てを順番にブロックに渡し、
その評価結果に置き換えます。

また、ブロックなしの場合と違い、ブロックの中からは
組み込み変数 $1, $2, $3, ... を問題なく参照できます。

@param pattern 置き換える文字列のパターンを表す文字列か正規表現。
文字列を指定した場合は全く同じ文字列にだけマッチする
@return 置換した場合は self、置換しなかった場合は nil

//emlist[例][ruby]{
str = 'abcabc'
str.gsub!(/b/) {|s| s.u...

絞り込み条件を変える

String#gsub!(pattern, replace) -> self | nil (328.0)

2.3.0

インスタンスメソッド

文字列中で pattern にマッチする部分全てを文字列 replace に破壊的に置き換えます。

文字列中で pattern にマッチする部分全てを文字列 replace に破壊的に置き換えます。

置換文字列 replace 中の \& と \0 はマッチした部分文字列に、
\1 ... \9 は n 番目の括弧の内容に置き換えられます。
置換文字列内では \`、\'、\+ も使えます。
これらは $`、$'、$+ に対応します。

gsub! は通常 self を変更して返しますが、
置換が起こらなかった場合は nil を返します。

@param pattern 置き換える文字列のパターンを表す文字列か正規表現。
文字列を指定した場合は全く...

String#gsub(pattern, replace) -> String (328.0)

2.3.0

インスタンスメソッド

文字列中で pattern にマッチする部分全てを文字列 replace で置き換えた文字列を生成して返します。

文字列中で pattern にマッチする部分全てを
文字列 replace で置き換えた文字列を生成して返します。

置換文字列 replace 中の \& と \0 はマッチした部分文字列に、
\1 ... \9 は n 番目の括弧の内容に置き換えられます。
置換文字列内では \`、\'、\+ も使えます。
これらは $`、$'、$+ に対応します。

@param pattern 置き換える文字列のパターンを表す文字列か正規表現。
文字列を指定した場合は全く同じ文字列にだけマッチする
@param replace pattern で指定した...

String#sub(pattern, replace) -> String (328.0)

2.3.0

インスタンスメソッド

文字列中で pattern にマッチした最初の部分を文字列 replace で置き換えた文字列を生成して返します。

文字列中で pattern にマッチした最初の部分を
文字列 replace で置き換えた文字列を生成して返します。

置換文字列 replace 中の \& と \0 はマッチした部分文字列に、
\1 ... \9 は n 番目の括弧の内容に置き換えられます。
置換文字列内では \`、\'、\+ も使えます。
これらは $`、$'、$+ に対応します。

@param pattern 置き換える文字列のパターンを表す文字列か正規表現。
文字列を指定した場合は全く同じ文字列にだけマッチする
@param replace pattern で指定し...

Struct#dig(key, ...) -> object | nil (328.0)

2.3.0

インスタンスメソッド

self 以下のネストしたオブジェクトを dig メソッドで再帰的に参照して返します。途中のオブジェクトが nil であった場合は nil を返します。

self 以下のネストしたオブジェクトを dig メソッドで再帰的に参照して返し
ます。途中のオブジェクトが nil であった場合は nil を返します。

@param key キーを任意個指定します。

//emlist[例][ruby]{
klass = Struct.new(:a)
o = klass.new(klass.new({b: [1, 2, 3]}))

o.dig(:a, :a, :b, 0) # => 1
o.dig(:b, 0) # => nil
//}

@see Array#dig, Hash#d...

UnboundMethod#owner -> Class | Module (328.0)

2.3.0

インスタンスメソッド

このメソッドが定義されている class か module を返します。

このメソッドが定義されている class か module を返します。

//emlist[例][ruby]{
Integer.instance_method(:to_s).owner # => Integer
Integer.instance_method(:to_c).owner # => Numeric
Integer.instance_method(:hash).owner # => Kernel
//}

絞り込み条件を変える

String#sub!(pattern) {|matched| .... } -> self | nil (319.0)

2.3.0

インスタンスメソッド

文字列中で pattern にマッチした最初の部分をブロックに渡し、その評価結果へ破壊的に置き換えます。

文字列中で pattern にマッチした最初の部分をブロックに渡し、
その評価結果へ破壊的に置き換えます。

また、ブロックなしの sub と違い、ブロックの中からは
組み込み変数 $1, $2, $3, ... を問題なく参照できます。

@param pattern 置き換える文字列のパターンを表す文字列か正規表現。
文字列を指定した場合は全く同じ文字列にだけマッチする
@return 置換した場合は self、置換しなかった場合は nil

//emlist[例][ruby]{
str = 'abcabc'
str.sub!(/b/) {|s|...

String#sub!(pattern, replace) -> self | nil (319.0)

2.3.0

インスタンスメソッド

文字列中で pattern にマッチした最初の部分を文字列 replace へ破壊的に置き換えます。

文字列中で pattern にマッチした最初の部分を文字列 replace へ破壊的に置き換えます。

置換文字列 replace 中の \& と \0 はマッチした部分文字列に、
\1 ... \9 は n 番目の括弧の内容に置き換えられます。
置換文字列内では \`、\'、\+ も使えます。
これらは $`、$'、$+ に対応します。

sub! は通常 self を変更して返しますが、
置換が起こらなかった場合は nil を返します。

@param pattern 置き換える文字列のパターンを表す文字列か正規表現。
文字列を指定した場合は全く...

別のキーワード

クラス

モジュール

キーワード

検索結果

先頭5件

Float#hash -> Integer (63367.0)

Rational#hash -> Integer (63331.0)

Hash#to_hash -> self (45757.0)

Hash#select {|key, value| ... } -> Hash (45649.0)

Hash#each_value {|value| ... } -> self (45646.0)

Hash#rehash -> self (45646.0)

Hash#has_value?(value) -> bool (45628.0)

Hash#value?(value) -> bool (45628.0)

Hash#clone -> Hash (45616.0)

Hash#default -> object | nil (45454.0)

Hash#default(key) -> object | nil (45454.0)

Hash#replace(other) -> self (45454.0)

Hash#default_proc=(pr) (45436.0)

Hash#default_proc -> Proc | nil (45400.0)

Hash#delete_if -> Enumerator (45382.0)

Hash#delete_if {|key, value| ... } -> self (45382.0)

Hash#values_at(*keys) -> [object] (45382.0)

Hash#select -> Enumerator (45349.0)

Hash#each_value -> Enumerator (45346.0)

Hash#equal?(other) -> bool (45346.0)

Hash#fetch_values(key, ...) -> [object] (45346.0)

Hash#fetch_values(key, ...) { |key| ... } -> [object] (45346.0)

Hash#values -> [object] (45346.0)

Hash#clear -> self (45328.0)

Hash#default=(value) (45328.0)

Hash#delete(key) -> object | nil (45328.0)

Hash#delete(key) {|key| ... } -> object (45328.0)

Hash#flatten(level = 1) -> Array (45310.0)

Hash#length -> Integer (45310.0)

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

Hash#select! -> Enumerator (36364.0)

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

Hash#eql?(other) -> bool (36346.0)

Hash#include?(key) -> bool (36328.0)

Hash#dup -> Hash (36316.0)

Hash#reject! -> Enumerator (36082.0)

Hash#size -> Integer (36010.0)

Hash#to_h -> self | Hash (27889.0)

Hash#merge(other) {|key, self_val, other_val| ... } -> Hash (27706.0)

Hash#reject {|key, value| ... } -> Hash (27685.0)

Hash#merge!(other) {|key, self_val, other_val| ... } -> self (27664.0)

Hash#update(other) {|key, self_val, other_val| ... } -> self (27664.0)

Hash#[](key) -> object | nil (27490.0)

Hash#<(other) -> bool (27382.0)

Hash#<=(other) -> bool (27382.0)

Hash#>(other) -> bool (27382.0)

Hash#>=(other) -> bool (27382.0)

Hash#shift -> [object, object] | nil (27382.0)

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

Hash#merge!(other) -> self (27364.0)

Hash#update(other) -> self (27364.0)

Hash#==(other) -> bool (27346.0)

Hash#===(other) -> bool (27346.0)

Hash#each {|key, value| ... } -> self (27346.0)

Hash#each_key {|key| ... } -> self (27346.0)

Hash#each_pair {|key, value| ... } -> self (27346.0)

Hash#index(val) -> object (27346.0)

Hash#key(val) -> object (27346.0)

Hash#[]=(key, value) (27328.0)

Hash#compare_by_identity -> self (27328.0)

Hash#compare_by_identity? -> bool (27328.0)

Hash#fetch(key, default) -> object (27328.0)

Hash#has_key?(key) -> bool (27328.0)

Hash#key?(key) -> bool (27328.0)

Hash#member?(key) -> bool (27328.0)

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

Hash#store(key, value) -> object (27328.0)

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

Hash#dig(key, ...) -> object | nil (27310.0)

Hash#empty? -> bool (27310.0)

Object#eql?(other) -> bool (18394.0)

String#eql?(other) -> bool (18346.0)

Numeric#eql?(other) -> bool (18328.0)

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