class Hash

[edit]

dynamic include: JSON::Generator::GeneratorMethods::Hash (by json)

要約

ハッシュテーブル(連想配列とも呼ぶ)のクラスです。ハッシュは任意の種類のオブジェクト(キー)から任意の種類のオブジェクト(値)への関連づけを行うことができます。

ハッシュ生成は多くの場合以下のようなリテラル (リテラル/ハッシュ式) で行われます。 

{a => b, ... }   # aはキー、bは値となる
{s: b , ... }    # { :s => b, ... } と同じ。キーがシンボルの場合の省略した書き方
{"a+": b , ... } # { :"a+" => b, ... } と同じ。上の表現に空白や記号を含めたい場合

キーには任意の種類のオブジェクトを用いることができますが、以下の２つのメソッドが適切に定義してある必要があります。

破壊的操作によってキーとして与えたオブジェクトの内容が変化し、Object#hash の返す値が変わるとハッシュから値が取り出せなくなりますから、 Array、Hash などのインスタンスはキーに向きません。Hash#rehash を参照。

ただし、 更新不可 (Object#frozen? が true) では無い文字列をキーとして与えた場合は、文字列をコピーし、コピーを更新不可に設定 (Object#freeze) してキーとして使用します。この為、キーとして使われている文字列を更新しようとすると例外 FrozenError が発生するので rehash を呼ぶ必要性は生じません。

ハッシュにはデフォルト値を設定することができます。存在しないキーを探索したときに返す値で、未設定時は nil です。デフォルト値には値形式とブロック形式があります。実際にデフォルト値がどのように扱われるかは各メソッドの説明を参照してください。

ハッシュに含まれる要素の順序が保持されるようになりました。ハッシュにキーが追加された順序で列挙します。

目次

特異メソッド
インスタンスメソッド

継承しているメソッド

Enumerableから継承しているメソッド

特異メソッド

self[other] -> Hash[permalink][rdoc][edit]

新しいハッシュを生成します。引数otherと同一のキーと値を持つ新たなハッシュを生成して返します。

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

デフォルト値はコピーしません。生成されたハッシュのデフォルト値は nil です。

引数otherと生成したハッシュは同じオブジェクトを参照することになるので、一方でキーや値に破壊的操作を行うともう片方にも影響します。

[PARAM] other:
生成元となるハッシュまたはメソッド to_hash でハッシュに変換できるオブジェクトです。 

h = {1 => "value"}
h.default = "none"

g = Hash[h]
p g #=> {1=>"value"}

p h[:no] #=> "none"
p g[:no] #=> nil

h[:add] = "some"
p h #=> {1=>"value", :add=>"some"}
p g #=> {1=>"value"}

h[1] << 'plus' #破壊的操作
p h #=> {1=>"valueplus", :add=>"some"}
p g #=> {1=>"valueplus"}
self[*key_and_value] -> Hash[permalink][rdoc][edit]

新しいハッシュを生成します。引数は必ず偶数個指定しなければなりません。奇数番目がキー、偶数番目が値になります。

このメソッドでは生成するハッシュにデフォルト値を指定することはできません。 Hash.newを使うか、Hash#default=で後から指定してください。

[PARAM] key_and_value:
生成するハッシュのキーと値の組です。必ず偶数個(0を含む)指定しなければいけません。
[EXCEPTION] ArgumentError:
奇数個の引数を与えたときに発生します。

以下は配列からハッシュを生成する方法の例です。

(1) [キー, 値, ...] の配列からハッシュへ 


ary = [1,"a", 2,"b", 3,["c"]]
p Hash[*ary]  # => {1=>"a", 2=>"b", 3=>["c"]}

(2) キーと値のペアの配列からハッシュへ 


alist = [[1,"a"], [2,"b"], [3,["c"]]]
p alist.flatten(1) # => [1, "a", 2, "b", 3, ["c"]]
p Hash[*alist.flatten(1)]  # => {1=>"a", 2=>"b", 3=>["c"]}

(3) キーと値の配列のペアからハッシュへ 


keys = [1, 2, 3]
vals = ["a", "b", ["c"]]
alist = keys.zip(vals)     # あるいは alist = [keys,vals].transpose
p alist # => [[1, "a"], [2, "b"], [3, ["c"]]]
p Hash[alist]  # => {1=>"a", 2=>"b", 3=>["c"]}

(4) キーや値が配列の場合 


alist = [[1,["a"]], [2,["b"]], [3,["c"]], [[4,5], ["a", "b"]]]
hash = Hash[alist] # => {1=>["a"], 2=>["b"], 3=>["c"], [4, 5]=>["a", "b"]}
new(ifnone = nil) -> Hash[permalink][rdoc][edit]

空の新しいハッシュを生成します。ifnone はキーに対応する値が存在しない時のデフォルト値です。設定したデフォルト値はHash#defaultで参照できます。

ifnoneを省略した Hash.new は {} と同じです。

デフォルト値として、毎回同一のオブジェクトifnoneを返します。それにより、一箇所のデフォルト値の変更が他の値のデフォルト値にも影響します。 


h = Hash.new([])
h[0] << 0
h[1] << 1
p h.default #=> [0, 1]

これを避けるには、破壊的でないメソッドで再代入する必要が有ります。また、このようなミスを防ぐためにもifnoneは freeze して破壊的操作を禁止しておくのが無難です。

[PARAM] ifnone:
キーに対応する値が存在しない時のデフォルト値です。 
例

h = Hash.new([])

p h[1]                  #=> []
p h[1].object_id        #=> 6127150
p h[1] << "bar"         #=> ["bar"]
p h[1]                  #=> ["bar"]

p h[2]                  #=> ["bar"]
p h[2].object_id        #=> 6127150

p h                     #=> {}


h = Hash.new([].freeze)
h[0] += [0] #破壊的でないメソッドはOK
h[1] << 1
# エラー: can't modify frozen Array (FrozenError)
new {|hash, key| ... } -> Hash[permalink][rdoc][edit]

空の新しいハッシュを生成します。ブロックの評価結果がデフォルト値になります。設定したデフォルト値はHash#default_procで参照できます。

値が設定されていないハッシュ要素を参照するとその都度ブロックを実行し、その結果を返します。ブロックにはそのハッシュとハッシュを参照したときのキーが渡されます。

[EXCEPTION] ArgumentError:
ブロックと通常引数を同時に与えると発生します。 
例

# ブロックではないデフォルト値は全部同一のオブジェクトなので、
# 破壊的変更によって他のキーに対応する値も変更されます。
h = Hash.new("foo")

p h[1]                  #=> "foo"
p h[1].object_id        #=> 6127170
p h[1] << "bar"         #=> "foobar"
p h[1]                  #=> "foobar"

p h[2]                  #=> "foobar"
p h[2].object_id        #=> 6127170

p h                     #=> {}

# ブロックを与えると、対応する値がまだ無いキーが呼び出される度に
# ブロックを評価するので、全て別のオブジェクトになります。
h = Hash.new {|hash, key| hash[key] = "foo"}

p h[1]                  #=> "foo"
p h[1].object_id        #=> 6126900
p h[1] << "bar"         #=> "foobar"
p h[1]                  #=> "foobar"

p h[2]                  #=> "foo"
p h[2].object_id        #=> 6126840

p h                     #=> {1=>"foobar", 2=>"foo"}

# 値が設定されていないときに(fetchのように)例外をあげるようにもできる
h = Hash.new {|hash, key|
                raise(IndexError, "hash[#{key}] has no value")
             }
h[1]
# エラー hash[1] has no value (IndexError)

[SEE_ALSO] Hash#default=,Hash#default,Hash#default_proc

try_convert(obj) -> Hash | nil[permalink][rdoc][edit]

to_hash メソッドを用いて obj をハッシュに変換しようとします。

何らかの理由で変換できないときには nil を返します。このメソッドは引数がハッシュであるかどうかを調べるために使えます。 


Hash.try_convert({1=>2})   # => {1=>2}
Hash.try_convert("1=>2")   # => nil

インスタンスメソッド

self < other -> bool[permalink][rdoc][edit]

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

[PARAM] other:
自身と比較したい Hash オブジェクトを指定します。 
例

h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 < h2    # => true
h2 < h1    # => false
h1 < h1    # => false

[SEE_ALSO] Hash#<=, Hash#>=, Hash#>

self <= other -> bool[permalink][rdoc][edit]

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

[PARAM] other:
自身と比較したい Hash オブジェクトを指定します。 
例

h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 <= h2   # => true
h2 <= h1   # => false
h1 <= h1   # => true

[SEE_ALSO] Hash#<, Hash#>=, Hash#>

self == other -> bool[permalink][rdoc][edit]
self === other -> bool
eql?(other) -> bool

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

[PARAM] other:
自身と比較したい Hash オブジェクトを指定します。 
例

#(出力関数は省略)
{ 1 => :a } == { 1 => :a }               #=> true
{ 1 => :a } == { 1 => :a, 2 => :b }      #=> false
{ 1 => :a } == { 1.0 => :a }             #=> false  ( 1.eql?(1.0) は false なので)

{ :x => 1 } == { :x => 1.0 }             #=> true   ( 1 == 1.0 は true なので)

[SEE_ALSO] Hash#equal?

self > other -> bool[permalink][rdoc][edit]

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

[PARAM] other:
自身と比較したい Hash オブジェクトを指定します。 
例

h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 > h2    # => false
h2 > h1    # => true
h1 > h1    # => false

[SEE_ALSO] Hash#<=, Hash#<, Hash#>=

self >= other -> bool[permalink][rdoc][edit]

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

[PARAM] other:
自身と比較したい Hash オブジェクトを指定します。 
例

h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 >= h2   # => false
h2 >= h1   # => true
h1 >= h1   # => true

[SEE_ALSO] Hash#<=, Hash#<, Hash#>

self[key] -> object | nil[permalink][rdoc][edit]

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

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

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

[PARAM] key:
探索するキーを指定します。 
例

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

h1 = Hash.new("default value")
p h1[:non]             #=> "default value"

h2 = Hash.new {|*arg| arg}
p h2[:non]             #=> [{}, :non]

[SEE_ALSO] Hash.new, Hash#fetch,Hash#values_at,Hash#key?, Hash#default, Hash#default_proc

self[key] = value[permalink][rdoc][edit]
store(key, value) -> object

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

[PARAM] key:
キーを指定します。
[PARAM] value:
値を指定します。 
例

h = {}

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

[SEE_ALSO] Hash#[]

assoc(key) -> Array | nil[permalink][rdoc][edit]

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

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

[PARAM] key:
検索するキー 
例

h = {"colors"  => ["red", "blue", "green"],
     "letters" => ["a", "b", "c" ]}
h.assoc("letters")  #=> ["letters", ["a", "b", "c"]]
h.assoc("foo")      #=> nil

[SEE_ALSO] Array#assoc

clear -> self[permalink][rdoc][edit]

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

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

例

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

h.clear

p h #=> {}
p h.default #=> "default value"
clone -> Hash[permalink][rdoc][edit]
dup -> Hash

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

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

例

h1 = {"have" => "have a","as" => "as a" }
h2 = h1.dup

h2["have"] = "has"
p h2 #=> {"have"=>"has", "as"=>"as a"}
p h1 #=> {"have"=>"have a", "as"=>"as a"}

h2["as"].upcase!
p h2 #=> {"have"=>"has", "as"=>"AS A"}
p h1 #=> {"have"=>"have a", "as"=>"AS A"}

[SEE_ALSO] Object#clone

compact -> Hash[permalink][rdoc][edit]
compact! -> self | nil

compact は自身から value が nil のもの取り除いた Hash を生成して返します。 compact! は自身から破壊的に value が nil のものを取り除き、変更が行われた場合は self を、そうでなければ nil を返します。 

例

hash = {a: 1, b: nil, c: 3}
p hash.compact  #=> {:a=>1, :c=>3}
p hash          #=> {:a=>1, :b=>nil, :c=>3}
hash.compact!
hash            #=> {:a=>1, :c=>3}
p hash.compact! #=>  nil

[SEE_ALSO] Array#compact

compare_by_identity -> self[permalink][rdoc][edit]

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

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

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

[RETURN]
selfを返します。 
例

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

h1.compare_by_identity

p h1.compare_by_identity? #=> true
p h1["a"]        #=> nil  # この"a"と最初の"a"とは違うオブジェクト
p h1[:c]         #=> "c"  # 同じ内容のシンボルはすべて同一

[SEE_ALSO] Hash#compare_by_identity?

compare_by_identity? -> bool[permalink][rdoc][edit]

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

例

h1 = {}
p h1.compare_by_identity? #=> false

h1.compare_by_identity

p h1.compare_by_identity? #=> true

[SEE_ALSO] Hash#compare_by_identity

default -> object | nil[permalink][rdoc][edit]
default(key) -> object | nil

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

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

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

[PARAM] key:
デフォルトのブロックにキーとして渡されます。 
例

h = Hash.new("default")
p h.default        #=> "default"
p h.default(:some) #=> "default"
p h #=>{}

h = Hash.new{|hash, key| hash[key] ="default" }
p h.default        #=> nil
p h.default(:some) #=> "default"
p h                #=> {:some=>"default"}

h = Hash.new
p h.default        #=> nil
p h.default(:some) #=> nil
p h                #=> {}

[SEE_ALSO] Hash#default=, Hash#default_proc

default=(value)[permalink][rdoc][edit]

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

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

[PARAM] value:
設定するデフォルト値です。
[RETURN]
value を返します。 
例

h = {}
p h.default #=>nil

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

[SEE_ALSO] Hash#default

default_proc -> Proc | nil[permalink][rdoc][edit]

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

例

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.new("default")
p h.default              #=> "default"
p h.default_proc         #=> nil

[SEE_ALSO] Hash#default

default_proc=(pr)[permalink][rdoc][edit]

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

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

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

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

[PARAM] pr:
デフォルト値を返す手続きオブジェクト 
例

h = {}
h.default_proc = proc do |hash, key|
  hash[key] = case
              when (key % 15).zero?
                "FizzBuzz"
              when (key % 5).zero?
                 "Buzz"
              when (key % 3).zero?
                 "Fizz"
              else
                 key
              end
end
p h[1]  # => 1
p h[2]  # => 2
p h[3]  # => "Fizz"
p h[5]  # => "Buzz"
p h[15] # => "FizzBuzz"

h.default_proc = nil
p h[16] # => nil
# default_proc が nil になったので `16=>16 が追加されていない`
p h     # => {1=>1, 2=>2, 3=>"Fizz", 5=>"Buzz", 15=>"FizzBuzz"}

[SEE_ALSO] Hash#default_proc, Hash#default

delete(key) -> object | nil[permalink][rdoc][edit]
delete(key) {|key| ... } -> object

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

[PARAM] key:
取り除くキーを指定します。
[RETURN]
取り除かれた要素の値を返します。 key に対応する要素が存在しない時には nil を返します。 与えられたブロックは key にマッチする要素がなかった時に評価され、その結果を返します。 
例

h = {:ab => "some" , :cd => "all"}

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

p h #=> {:cd=>"all"}

[SEE_ALSO] Hash#delete_if

delete_if -> Enumerator[permalink][rdoc][edit]
reject! -> Enumerator
delete_if {|key, value| ... } -> self
reject! {|key, value| ... } -> self|nil

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

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

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

例

h = { 2 => "8" ,4 => "6" ,6 => "4" ,8 => "2" }

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

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

[SEE_ALSO] Hash#reject,Hash#delete

[SEE_ALSO] Hash#keep_if,Hash#select!

dig(key, ...) -> object | nil[permalink][rdoc][edit]

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

[PARAM] key:
キーを任意個指定します。 
例

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_ALSO] Array#dig, Struct#dig, OpenStruct#dig

each {|key, value| ... } -> self[permalink][rdoc][edit]
each_pair {|key, value| ... } -> self
each -> Enumerator
each_pair -> Enumerator

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

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

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

例

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

{:a=>1, :b=>2}.each_pair {|*a| p a} 
#=> [[:a, 1]]
#   [[:b, 2]]

{:a=>1, :b=>2}.each {|k, v| p [k, v]}  #each_pairでも同じ結果
#=> [:a, 1]
#   [:b, 2]

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

[SEE_ALSO] Hash#each_key,Hash#each_value

each_key {|key| ... } -> self[permalink][rdoc][edit]
each_key -> Enumerator

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

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

例

{: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_ALSO] Hash#each_pair,Hash#each_value

each_value {|value| ... } -> self[permalink][rdoc][edit]
each_value -> Enumerator

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

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

例

{: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_ALSO] Hash#each_pair,Hash#each_key

empty? -> bool[permalink][rdoc][edit]

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

例

puts({}.empty?) #=> true
equal?(other) -> bool[permalink][rdoc][edit]

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

[PARAM] other:
自身と比較したい Hash オブジェクトを指定します。 
例

p({}.equal?({}))     #=> false 
a = {}
p a.equal?(a)        #=> true

[SEE_ALSO] Hash#==

fetch(key, default = nil) {|key| ... } -> object[permalink][rdoc][edit]

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

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

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

h = {one: nil}
p h[:one],h[:two]                        #=> nil,nil これではキーが存在するのか判別できない。
p h.fetch(:one)                          #=> nil
p h.fetch(:two)                          # エラー key not found (KeyError)
p h.fetch(:two,"error")                  #=> "error"
p h.fetch(:two){|key|"#{key} not exist"} #=> "two not exist"
p h.fetch(:two, "error"){|key|           #=> "two not exist"
    "#{key} not exist"                   #  warning: block supersedes default value argument
  }                                      #  警告が表示される。

h.default = "default"
p h.fetch(:two)                          # エラー key not found (KeyError)

[SEE_ALSO] Hash#[]

fetch_values(key, ...) -> [object][permalink][rdoc][edit]
fetch_values(key, ...) { |key| ... } -> [object]

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

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

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

[PARAM] key:
探索するキーを任意個指定します。
[EXCEPTION] KeyError:
ブロックが与えられてない時にキーの探索に失敗すると発生します。 
例

h = { "cat" => "feline", "dog" => "canine", "cow" => "bovine" }

h.fetch_values("cow", "cat")                   # => ["bovine", "feline"]
h.fetch_values("cow", "bird")                  # raises KeyError
h.fetch_values("cow", "bird") { |k| k.upcase } # => ["bovine", "BIRD"]

[SEE_ALSO] Hash#values_at, Hash#fetch

select -> Enumerator[permalink][rdoc][edit]
select {|key, value| ... } -> Hash
filter -> Enumerator
filter {|key, value| ... } -> Hash

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

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


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_ALSO] Hash#select!, Hash#reject

keep_if -> Enumerator[permalink][rdoc][edit]
keep_if {|key, value| ... } -> self
select! -> Enumerator
select! {|key, value| ... } -> self | nil
filter! -> Enumerator
filter! {|key, value| ... } -> self | nil

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

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

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

例

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

h2 = h1.dup
h1.select!  # => #<Enumerator: {0=>"a", 1=>"b", 2=>"c", 3=>"d", 4=>"e", 5=>"f", 6=>"g"}:select!>

h1.select! { |k, v| k % 3 == 0 }  # => {0=>"a", 3=>"d", 6=>"g"}
h1.select! { |k, v| true }        # => nil
h2.keep_if { |k, v| k % 3 == 0 }  # => {0=>"a", 3=>"d", 6=>"g"}
h2.keep_if { |k, v| true }        # => {0=>"a", 3=>"d", 6=>"g"}

[SEE_ALSO] Hash#select, Hash#delete_if, Hash#reject!

flatten(level = 1) -> Array[permalink][rdoc][edit]

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

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

[PARAM] level:
展開するレベル 
例

a =  {1=> "one", 2 => [2,"two"], 3 => "three"}
a.flatten     #=> [1, "one", 2, [2, "two"], 3, "three"]
a.flatten(1)  #=> [1, "one", 2, [2, "two"], 3, "three"]
a.flatten(2)  #=> [1, "one", 2, 2, "two", 3, "three"]
a.flatten(0)  #=> [[1, "one"], [2, [2, "two"]], [3, "three"]]
a.flatten(-1) #=> [1, "one", 2, 2, "two", 3, "three"]

[SEE_ALSO] Array#flatten

has_key?(key) -> bool[permalink][rdoc][edit]
include?(key) -> bool
key?(key) -> bool
member?(key) -> bool

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

[PARAM] key:
探索するキーを指定します。 

p({1 => "one"}.key?(1)) # => true
p({1 => "one"}.key?(2)) # => false

[SEE_ALSO] Hash#value?

has_value?(value) -> bool[permalink][rdoc][edit]
value?(value) -> bool

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

[PARAM] value:
探索する値を指定します。 

p({1 => "one"}.value?("one")) #=> true
p({1 => "one"}.value?("two")) #=> false

[SEE_ALSO] Hash#key?

hash -> Integer[permalink][rdoc][edit]

自身が保持するキーと値のハッシュ値を元にして算出した整数を返します。自身が保持するキーや値が変化すればこのメソッドが返す値も変化します。 

例

a = {}
p a.hash     #=> 0
a[1] = :x
p a.hash     #=> 329543
key(val) -> object[permalink][rdoc][edit]
index(val) -> object

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

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

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

[PARAM] val:
探索に用いる値を指定します。 
例

h = {:ab => "some" , :cd => "all" , :ef => "all"}

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

[SEE_ALSO] Hash#invert

to_s -> String[permalink][rdoc][edit]
inspect -> String

ハッシュの内容を人間に読みやすい文字列にして返します。 

例

h = { "c" => 300, "a" => 100, "d" => 400  }
h.inspect   # => "{\"c\"=>300, \"a\"=>100, \"d\"=>400}"
invert -> Hash[permalink][rdoc][edit]

値からキーへのハッシュを作成して返します。

異なるキーに対して等しい値が登録されている場合、最後に定義されている値が使用されます。 

例

h = { "a" => 0, "b" => 100, "c" => 200, "d" => 300, "e" => 300 }
p h.invert   #=> {0=>"a", 100=>"b", 200=>"c", 300=>"e"}

参考

値が重複していたときに備えて、変換後の値を配列として保持するには、次のようにします。 


def safe_invert(orig_hash)
  orig_hash.each_key.group_by do |key|
    orig_hash[key]
  end
end
p safe_invert({"a"=>1, "b"=>1, "c"=>3}) # => {1=>["a", "b"], 3=>["c"]}

[SEE_ALSO] Hash#key

keys -> [object][permalink][rdoc][edit]

全キーの配列を返します。 

例

h1 = { "a" => 100, 2 => ["some"], :c => "c" }
p h1.keys           #=> ["a", 2, :c]

[SEE_ALSO] Hash#values,Hash#to_a

length -> Integer[permalink][rdoc][edit]
size -> Integer

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


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
merge(*others) -> Hash[permalink][rdoc][edit]
merge(*others) {|key, self_val, other_val| ... } -> Hash

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

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

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

[PARAM] others:
マージ用のハッシュまたはメソッド to_hash でハッシュに変換できるオブジェクトです。
[RETURN]
マージした結果を返します 

h1 = { "a" => 100, "b" => 200 }
h2 = { "b" => 246, "c" => 300 }
h3 = { "b" => 357, "d" => 400 }
h1.merge          #=> {"a"=>100, "b"=>200}
h1.merge(h2)      #=> {"a"=>100, "b"=>246, "c"=>300}
h1.merge(h2, h3)  #=> {"a"=>100, "b"=>357, "c"=>300, "d"=>400}
h1.merge(h2) {|key, oldval, newval| newval - oldval}
                  #=> {"a"=>100, "b"=>46,  "c"=>300}
h1.merge(h2, h3) {|key, oldval, newval| newval - oldval}
                  #=> {"a"=>100, "b"=>311, "c"=>300, "d"=>400}
h1                #=> {"a"=>100, "b"=>200}


foo = {1 => 'a', 2 => 'b', 3 => 'c'}
bar = {2 => 'B', 3 => 'C', 4 => 'D'}

p foo.merge(bar)
       # => {1=>"a", 2=>"B", 3=>"C", 4=>"D"}
p foo  # => {1=>"a", 2=>"b", 3=>"c"}

p foo.merge!(bar) {|key, foo_val, bar_val| foo_val + bar_val }
       # => {1=>"a", 2=>"bB", 3=>"cC", 4=>"D"}
p foo  # => {1=>"a", 2=>"bB", 3=>"cC", 4=>"D"}


class Foo
  def to_hash
    {:Australia => 'Sydney',
     :France => 'Paris'
     }
  end
end

h = {:Germany => 'Berlin',
     :Australia => 'Canberra',
     :France => 'Paris'
     }

# 暗黙の変換
p h.merge(Foo.new) # => {:Germany=>"Berlin", :Australia=>"Sydney", :France=>"Paris"}

[SEE_ALSO] Hash#update,Hash#replace

merge!(*others) -> self[permalink][rdoc][edit]
merge!(*others) {|key, self_val, other_val| ... } -> self
update(*others) -> self
update(*others) {|key, self_val, other_val| ... } -> self

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

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

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

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

[PARAM] others:
マージ用のハッシュまたはメソッド to_hash でハッシュに変換できるオブジェクトです。
[RETURN]
マージ後のselfを返します。 

h1 = { "a" => 100, "b" => 200 }
h1.merge!          #=> {"a"=>100, "b"=>200}
h1                 #=> {"a"=>100, "b"=>200}


h1 = { "a" => 100, "b" => 200 }
h2 = { "b" => 246, "c" => 300 }
h1.merge!(h2)      #=> {"a"=>100, "b"=>246, "c"=>300}
h1                 #=> {"a"=>100, "b"=>246, "c"=>300}


h1 = { "a" => 100, "b" => 200 }
h2 = { "b" => 246, "c" => 300 }
h3 = { "b" => 357, "d" => 400 }
h1.merge!(h2, h3)  #=> {"a"=>100, "b"=>357, "c"=>300, "d"=>400}
h1                 #=> {"a"=>100, "b"=>357, "c"=>300, "d"=>400}


h1 = { "a" => 100, "b" => 200 }
h2 = { "b" => 246, "c" => 300 }
h3 = { "b" => 357, "d" => 400 }
h1.merge!(h2, h3) {|key, v1, v2| v1 }
                   #=> {"a"=>100, "b"=>200, "c"=>300, "d"=>400}
h1                 #=> {"a"=>100, "b"=>200, "c"=>300, "d"=>400}


foo = {1 => 'a', 2 => 'b', 3 => 'c'}
bar = {2 => 'B', 3 => 'C', 4 => 'D'}

p foo.update(bar) #=> {1=>"a", 2=>"B", 3=>"C", 4=>"D"}
p foo  #=> {1=>"a", 2=>"B", 3=>"C", 4=>"D"}

p foo.update(bar) {|key, foo_val, bar_val| foo_val + bar_val } # => {1=>"a", 2=>"BB", 3=>"CC", 4=>"DD"}
p foo  # => {1=>"a", 2=>"BB", 3=>"CC", 4=>"DD"}

[SEE_ALSO] Hash#merge,Hash#replace

rassoc(value) -> Array | nil[permalink][rdoc][edit]

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

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

[PARAM] value:
探索する値。 
例

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

[SEE_ALSO] Hash#assoc, Array#rassoc

rehash -> self[permalink][rdoc][edit]

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

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

[EXCEPTION] RuntimeError:
Hash#eachなどのイテレータの評価途中でrehashすると発生します。
[RETURN]
selfを返します。 
例

a = [ "a", "b" ]
h = { a => 100 }

p h[a]       #=> 100

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

h.rehash
p h[a]       #=> 100

[SEE_ALSO] Object#hash

reject {|key, value| ... } -> Hash[permalink][rdoc][edit]
reject -> Enumerator

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

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

例

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_ALSO] Hash#delete_if,Hash#delete,Enumerable#reject

replace(other) -> self[permalink][rdoc][edit]

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

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

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

[PARAM] other:
ハッシュまたはメソッド to_hash でハッシュに変換できるオブジェクトです。
[RETURN]
self を返します。 
例

foo = {1 => 'a', 2 => 'b'}
bar = {2 => 'B', 3 => 'C'}

foo.replace(bar)
p foo  #=> {2=>"B", 3=>"C"}

zoo = {}
zoo = bar.dup
p zoo  #=> {2=>"B", 3=>"C"}

class Foo
  def to_hash
    {:japan => 'kyoto'}
  end
end

h = Hash.new
h.replace(Foo.new) #暗黙の変換
p h #=> {:japan=>"kyoto"}

[SEE_ALSO] Hash#dup,Hash#merge,Object#to_hash

shift -> [object, object][permalink][rdoc][edit]

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

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

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

例

h = {:ab => "some" , :cd => "all"}
p h.shift               #=> [:ab, "some"]
p h.shift               #=> [:cd, "all"]
p h                     #=> {}
p h.shift               #=> nil

h1 = Hash.new("default value")
p h1                    #=> {}
p h1.shift              #=> "default value"

h2 = Hash.new {|*arg| arg}
p h2                    #=> {}
p h2.shift              #=> [{}, nil]

[SEE_ALSO] Array#shift

slice(*keys) -> Hash[permalink][rdoc][edit]

引数で指定されたキーとその値だけを含む Hash を返します。 

例

h = { a: 100, b: 200, c: 300 }
h.slice(:a)           # => {:a=>100}
h.slice(:c, :b)       # => {:c=>300, :b=>200}
h.slice(:b, :c, :d)   # => {:b=>200, :c=>300}

[SEE_ALSO] ENV.slice

to_a -> [Array][permalink][rdoc][edit]

キーと値からなる 2 要素の配列を並べた配列を生成して返します。 

例

h1 = { "a" => 100, 2 => ["some"], :c => "c" }
p h1.to_a           #=> [["a", 100], [2, ["some"]], [:c, "c"]]

[SEE_ALSO] Hash#keys,Hash#values

to_h -> self | Hash[permalink][rdoc][edit]
to_h {|key, value| block } -> Hash

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

例

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 = { "a" => 97, "b" => 98 }
hash.to_h {|key, value| [key.upcase, value-32] } # => {"A"=>65, "B"=>66}

[SEE_ALSO] Enumerable#map

to_hash -> self[permalink][rdoc][edit]

self を返します。 

例

hash = {}
p hash.to_hash         # => {}
p hash.to_hash == hash # => true

[SEE_ALSO] Object#to_hash, Hash#to_h

to_proc -> Proc[permalink][rdoc][edit]

self のキーに対応する値を返す Proc オブジェクトを返します。 


h = {1 => 10, 2 => 20, 3 => 30}
[1, 2, 3].map(&h) # => [10, 20, 30]
transform_keys {|key| ... } -> Hash[permalink][rdoc][edit]
transform_keys -> Enumerator

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

例

h = { a: 1, b: 2, c: 3 }
h.transform_keys {|k| k.to_s }   # => {"a"=>1, "b"=>2, "c"=>3}
h.transform_keys(&:to_s)         # => {"a"=>1, "b"=>2, "c"=>3}
h.transform_keys.with_index {|k, i| "#{k}.#{i}" }
                                 # => {"a.0"=>1, "b.1"=>2, "c.2"=>3}

[SEE_ALSO] Hash#transform_keys!

[SEE_ALSO] Hash#transform_values

[SEE_ALSO] Hash#transform_values!

transform_keys! {|key| ... } -> self[permalink][rdoc][edit]
transform_keys! -> Enumerator

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

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

h = { a: 1, b: 2, c: 3 }
h.transform_keys! {|k| k.to_s }   # => {"a"=>1, "b"=>2, "c"=>3}
h.transform_keys!(&:to_sym)       # => {:a=>1, :b=>2, :c=>3}
h.transform_keys!.with_index {|k, i| "#{k}.#{i}" }
                                  # => {"a.0"=>1, "b.1"=>2, "c.2"=>3}

[SEE_ALSO] Hash#transform_keys

[SEE_ALSO] Hash#transform_values

[SEE_ALSO] Hash#transform_values!

transform_values {|value| ... } -> Hash[permalink][rdoc][edit]
transform_values -> Enumerator

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

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

h = { a: 1, b: 2, c: 3 }
h.transform_values {|v| v * v + 1 }  #=> { a: 2, b: 5, c: 10 }
h.transform_values(&:to_s)           #=> { a: "1", b: "2", c: "3" }
h.transform_values.with_index {|v, i| "#{v}.#{i}" }
                                     #=> { a: "1.0", b: "2.1", c: "3.2" }

[SEE_ALSO] Hash#transform_values!

[SEE_ALSO] Hash#transform_keys

[SEE_ALSO] Hash#transform_keys!

transform_values! {|value| ... } -> self[permalink][rdoc][edit]
transform_values! -> Enumerator

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

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

h = { a: 1, b: 2, c: 3 }
h.transform_values! {|v| v * v + 1 }  #=> { a: 2, b: 5, c: 10 }
h.transform_values!(&:to_s)           #=> { a: "2", b: "5", c: "10" }
h.transform_values!.with_index {|v, i| "#{v}.#{i}" }
                                      #=> { a: "2.0", b: "5.1", c: "10.2" }

[SEE_ALSO] Hash#transform_values

[SEE_ALSO] Hash#transform_keys

[SEE_ALSO] Hash#transform_keys!

values -> [object][permalink][rdoc][edit]

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

例

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

[SEE_ALSO] Hash#keys,Hash#to_a

values_at(*keys) -> [object][permalink][rdoc][edit]

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

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

[PARAM] keys:
キーを 0 個以上指定します。
[RETURN]
引数で指定されたキーに対応する値の配列を返します。引数が指定されなかった場合は、空の配列を返します。 
例

h = {1=>"a", 2=>"b", 3=>"c"}

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

[SEE_ALSO] Hash#[], Hash.new, Hash#default, Hash#default_proc, Array#values_at