Ruby 1.8.7 リファレンスマニュアル > ライブラリ一覧 > 組み込みライブラリ > Hashクラス
クラスの継承リスト: Hash < Enumerable < Object < Kernel
ハッシュテーブル(連想配列とも呼ぶ)のクラスです。ハッシュは任意の種類のオブ ジェクト(キー)から任意の種類のオブジェクト(値)への関連づけを行うことができます。
ハッシュ生成は多くの場合以下のようなリテラル (リテラル/ハッシュ式) で行われます。
{a => b, ... } # aはキー、bは値となる
キーには任意の種類のオブジェクトを用いることができますが、 以下の２つのメソッドが適切に定義してある必要があります。
破壊的操作によってキーとして与えたオブジェクトの内容が変化し、Object#hash の返す 値が変わるとハッシュから値が取り出せなくなりますから、 Array などのインスタンスはキーに向きません。Hash#rehash を参照。
ただし、 更新不可 (Object#frozen? が true) では無い文字列をキーとして与えた場合は、文字列をコピーし、コピーを更新不可に設定 (Object#freeze) してキーとして 使用します。この為、キーとして使われている文字列を更新しようとすると例外 TypeError が発生するので rehash を呼ぶ必要性は生じません。
ハッシュにはデフォルト値を設定することができます。存在しないキーを探索したときに返す値で、未設定時は nil です。 デフォルト値には値形式とブロック形式があります。 実際にデフォルト値がどのように扱われるかは各メソッドの説明を参照してください。
ハッシュに含まれる要素の順序は保持されません。 列挙する順序は不定です。
self[other] -> Hash[permalink][rdoc]新しいハッシュを生成します。 引数otherと同一のキーと値を持つ新たなハッシュを生成して返します。
引数otherがハッシュではない場合、otherのメソッドto_hashを使って暗黙の変換を試みます。
デフォルト値はコピーしません。生成されたハッシュのデフォルト値は nil です。
引数otherと生成したハッシュは同じオブジェクトを参照することになるので、 一方でキーや値に破壊的操作を行うともう片方にも影響します。
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]新しいハッシュを生成します。 引数は必ず偶数個指定しなければなりません。奇数番目がキー、偶数番目が値になります。
このメソッドでは生成するハッシュにデフォルト値を指定することはできません。 Hash.newを使うか、Hash#default=で後から指定してください。
以下は配列からハッシュを生成する方法の例です。
(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 Hash[*alist.flatten] # => {1=>"a", 2=>"b", 3=>"c"}
(3) キーと値の配列のペアからハッシュへ
keys = [1, 2, 3]
vals = ["a", "b", "c"]
alist = keys.zip(vals) # あるいは alist = [keys,vals].transpose
p Hash[*alist.flatten] # => {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]空の新しいハッシュを生成します。ifnone はキーに対 応する値が存在しない時のデフォルト値です。設定したデフォルト値はHash#defaultで参照できます。
ifnoneを省略した Hash.new は {} と同じです。
デフォルト値として、毎回同一のオブジェクトifnoneを返します。 それにより、一箇所のデフォルト値の変更が他の値のデフォルト値にも影響します。
h = Hash.new([]) h[0] << 0 h[1] << 1 p h.default #=> [0, 1]
これを避けるには、破壊的でないメソッドで再代入する必要が有ります。 また、このようなミスを防ぐためにもifnoneは freeze して破壊的操作を禁止しておくのが無難です。
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 (TypeError)
new {|hash, key| ... } -> Hash[permalink][rdoc]空の新しいハッシュを生成します。ブロックの評価結果がデフォルト値になりま す。設定したデフォルト値はHash#default_procで参照できます。
値が設定されていないハッシュ要素を参照するとその都度ブロックを 実行し、その結果を返します。 ブロックにはそのハッシュとハッシュを参照したときのキーが渡されます。
# ブロックではないデフォルト値は全部同一のオブジェクトなので、
# 破壊的変更によって他のキーに対応する値も変更されます。
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
self == other -> bool[permalink][rdoc]self === other -> booleql?(other) -> bool自身と other が同じ数のキーを保持し、キーが eql? メソッドで比較して全て等しく、 値が == メソッドで比較して全て等しい場合に真を返します。
#(出力関数は省略)
{ 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[key] -> object | nil[permalink][rdoc]key に関連づけられた値を返します。
該当するキーが登録されていない時には、デフォルト値を返します。
デフォルト値と値としての nil を区別する必要が ある場合は Hash#fetch または Hash#has_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#has_key?, Hash#default, Hash#default_proc
self[key] = value[permalink][rdoc]store(key, value) -> objectkey に対して value を関連づけます。value を返し ます。
h = {}
h[:key] = "value"
p h #=>{:key => "value"}
[SEE_ALSO] Hash#[]
clear -> self[permalink][rdoc]ハッシュの中身を空にします。
空にした後の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]dup -> Hashselfと同じ内容を持つ新しいハッシュを返します。
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
default -> object | nil[permalink][rdoc]default(key) -> object | nilハッシュのデフォルト値を返します。
ハッシュのデフォルト値がブロックで与えられている場合、 1 番目の形式だと 返り値が nil になることに注意してください。この場合、ハッシュのデフォルト値に ついて調べるには 2 番目の形式か Hash#default_proc を使ってください。
2 番目の形式はハッシュがデフォルト値としてブロックを持つ場合に、 self と引数 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]ハッシュのデフォルト値を value に変更します。対応する値が存 在しないキーで検索した時にはこの値を返すようになります。
デフォルト値（ブロックを含む）が既に設定してあった場合も value で上書きします。
h = {}
p h.default #=>nil
h.default = "default"
p h.default #=>"default"
[SEE_ALSO] Hash#default
default_proc -> Proc | nil[permalink][rdoc]ハッシュのデフォルト値を返す 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
delete(key) -> object | nil[permalink][rdoc]delete(key) {|key| ... } -> objectkey に対応する要素を取り除きます。
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 -> Enumerable::Enumerator[permalink][rdoc]reject! -> Enumerable::Enumeratordelete_if {|key, value| ... } -> selfreject! {|key, value| ... } -> self|nilキーと値を引数としてブロックを評価した結果が真であ るような要素を self から削除します。
delete_if は常に self を返します。 reject! は、要素を削除しなかった場合には nil を返し、 そうでなければ self を返します。
ブロックを省略した場合は Enumerable::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
each {|key, value| ... } -> self[permalink][rdoc]each_pair {|key, value| ... } -> selfeach -> Enumerable::Enumeratoreach_pair -> Enumerable::Enumeratorハッシュのキーと値を引数としてブロックを評価します。
反復の際の評価順序は不定です。 ブロック付きの場合 self を、 無しで呼ばれた場合 Enumerable::Enumerator を返します。
each と each_pair ではブロック引数の受渡し方が異なります。 each は キーと値の配列を１引数で、each_pair は別々に２引数でブロックに値を渡します。 これによりブロック引数をひとつだけ指定した場合の挙動が異なります。 ブロック引数を２つ指定するようにすれば同じ挙動になります。
{: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]
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) # => #<Enumerable::Enumerator:0xbb19e4>
[SEE_ALSO] Hash#each_key,Hash#each_value
each_key {|key| ... } -> self[permalink][rdoc]each_key -> Enumerable::Enumeratorハッシュのキーを引数としてブロックを評価します。
反復の際の評価順序は不定です。 ブロック付きの場合selfを、 無しで呼ばれた場合Enumerable::Enumeratorを返します。
{:a=>1, :b=>2}.each_key {|k| p k}
#=> :a
:b
p({:a=>1, :b=>2}.each_key) #=> #<Enumerable::Enumerator:0xbb19e4>
[SEE_ALSO] Hash#each_pair,Hash#each_value
each_value {|value| ... } -> self[permalink][rdoc]each_value -> Enumerable::Enumeratorハッシュの値を引数としてブロックを評価します。
反復の際の評価順序は不定です。 ブロック付きの場合selfを、 無しで呼ばれた場合 Enumerable::Enumerator を返します。
{:a=>1, :b=>2}.each_value {|v| p v}
#=> 1
2
p({:a=>1, :b=>2}.each_value) #=> #<Enumerable::Enumerator:0xbb19e4>
[SEE_ALSO] Hash#each_pair,Hash#each_key
empty? -> bool[permalink][rdoc]ハッシュが空の時、真を返します。
puts({}.empty?) #=> true
equal?(other) -> bool[permalink][rdoc]指定された other が self 自身である場合のみ真を返します。
p({}.equal?({})) #=> false
a = {}
p a.equal?(a) #=> true
[SEE_ALSO] Hash#==
fetch(key, default = nil) {|key| ... } -> object[permalink][rdoc]key に関連づけられた値を返します。該当するキーが登録されてい ない時には、引数 default が与えられていればその値を、ブロッ クが与えられていればそのブロックを評価した値を返します。
fetchはハッシュ自身にデフォルト値が設定されていても単に無視します（挙動に変化がありません）。
h = {:one => nil}
p h[:one],h[:two] #=> nil,nil これではキーが存在するのか判別できない。
p h.fetch(:one) #=> nil
p h.fetch(:two) # エラー key not found (IndexError)
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 exit" # warning: block supersedes default value argument
} # 警告が表示される。
h.default = "default"
p h.fetch(:two) # エラー key not found (IndexError)
[SEE_ALSO] Hash#[]
has_key?(key) -> bool[permalink][rdoc]include?(key) -> boolkey?(key) -> boolmember?(key) -> boolハッシュが key をキーとして持つ時真を返します。
p({1 => "one"}.has_key?(1)) #=> true
p({1 => "one"}.has_key?(2)) #=> false
[SEE_ALSO] Hash#has_value?
has_value?(value) -> bool[permalink][rdoc]value?(value) -> boolハッシュが value を値として持つ時真を返します。 値の一致判定は == で行われます。
p({1 => "one"}.has_value?("one")) #=> true
p({1 => "one"}.has_value?("two")) #=> false
[SEE_ALSO] Hash#has_key?
hash -> Integer[permalink][rdoc]自身が保持するキーと値のハッシュ値を元にして算出した整数を返します。 自身が保持するキーや値が変化すればこのメソッドが返す値も変化します。
a = {}
p a.hash #=> 0
a[1] = :x
p a.hash #=> 329543
index(val) -> object[permalink][rdoc]値 val に対応するキーを返します。対応する要素が存在しない時には nil を返します。
該当するキーが複数存在する場合、どのキーを返すかは不定です。
Hash#index は obsolete です。 使用すると警告メッセージが表示されます。
h = {:ab => "some" , :cd => "all" , :ef => "all"}
p h.index("some") #=> :ab
p h.index("all") #=> :cd
p h.index("at") #=> nil
[SEE_ALSO] Hash#invert
indexes(*keys) -> [object][permalink][rdoc]indices(*keys) -> [object]引数で指定されたキーに対応する値の配列を返します。
このメソッドは obsolete です。 使用すると警告メッセージが表示されます。 代わりに Hash#values_at を使用してください。
[SEE_ALSO] Hash#values_at,Hash#[]
inspect -> String[permalink][rdoc]ハッシュの内容を人間に読みやすい文字列にして返します。
h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300 }
h.inspect # => "{\"a\"=>100, \"c\"=>300, \"d\"=>400}"
invert -> Hash[permalink][rdoc]値からキーへのハッシュを作成して返します。
異なるキーに対して等しい値が登録されている場合の結果は不定であることに 注意してください、そのような場合にこのメソッドを利用することは意図され ていません。
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)
result = Hash.new{|h,key| h[key] = [] }
orig_hash.each{|key, value|
result[value] << key
}
result
end
p safe_invert({"a"=>1, "b"=>1, "c"=>3})
#=> {1=>["a", "b"], 3=>["c"]}
#転載：Rubyレシピブック No.120
[SEE_ALSO] Hash#index
keys -> [object][permalink][rdoc]全キーの配列を返します。
h1 = { "a" => 100, 2 => ["some"], :c => "c" }
p h1.keys #=> ["a", 2, :c]
[SEE_ALSO] Hash#values,Hash#to_a
length -> Integer[permalink][rdoc]size -> Integerハッシュの要素の数を返します。
puts({:ant => 9 ,:dog => 101 ,:cat => 3}.length) #=> 3
merge(other) -> Hash[permalink][rdoc]merge(other) {|key, self_val, other_val| ... } -> Hashmerge!(other) -> selfmerge!(other) {|key, self_val, other_val| ... } -> selfselfとotherのハッシュの内容をマージ(統合)した結果を返します。デフォルト値はselfの設定のままです。
self と other に同じキーがあった場合はブロック付きか否かで 判定方法が違います。ブロック付きのときはブロックを呼び出して その返す値を重複キーに対応する値にします。ブロック付きでない 場合は常に other の値を使います。
Hash#merge! は、マージの結果でselfを変更する破壊的メソッドで、Hash#update の別名です。
otherがハッシュではない場合、otherのメソッドto_hashを使って暗黙の変換を試みます。
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'
}
h.merge!(Foo.new) #暗黙の変換
p h #=> {:Germany=>"Berlin", :Australia=>"Sydney", :France=>"Paris"}
[SEE_ALSO] Hash#update,Hash#replace
rehash -> self[permalink][rdoc]キーのハッシュ値を再計算します。
キーになっているオブジェクトの内容が変化した時など、 ハッシュ値が変わってしまった場合はこのメソッドを使ってハッシュ値を再計算しない 限り、そのキーに対応する値を取り出すことができなくなります。
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]reject -> Enumerable::Enumeratorself を複製して、ブロックを評価した値が真になる要 素を削除したハッシュを返します。
ハッシュを返すことを除けば 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]ハッシュの内容を other の内容で置き換えます。
デフォルト値の設定もotherの内容になります。 otherがハッシュではない場合、otherのメソッドto_hashを使って暗黙の変換を試みます。
self = other.to_hash.dup と同じです。
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
select -> Enumerable::Enumerator[permalink][rdoc]select {|key, value| ... } -> Arraykey, value のペアについてブロックを評価し、真となるペアだけを含む 配列を生成して返します。
生成される配列は、[key, value] を要素とする配列です。
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]]
shift -> [object, object][permalink][rdoc]ハッシュから要素をひとつ取り除き、[key, value]という配列とし て返します。shiftがどの要素を返すかは不定です。
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
sort -> Array[permalink][rdoc]sort {|a, b| ... } -> Arrayハッシュを [key, value] を要素とする配列の配列に変換して，それをソー トした配列を返します。
h = { "a" => 20, "b" => 30, "c" => 10 }
h.sort #=> [["a", 20], ["b", 30], ["c", 10]]
h.sort {|a,b| a[1]<=>b[1]} #=> [["c", 10], ["a", 20], ["b", 30]]
[SEE_ALSO] Array#sort
to_a -> [Array][permalink][rdoc]キーと値からなる 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_hash -> self[permalink][rdoc]self を返します。
[SEE_ALSO] Object#to_hash
to_s -> String[permalink][rdoc]ハッシュの内容を self.to_a.to_s で文字列化して返します。
h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300 }
h.to_s # => "a100c300d400"
update(other) -> self[permalink][rdoc]update(other) {|key, self_val, other_val| ... } -> selfselfとotherのハッシュの内容をマージ(統合)します。Hash#merge!と同じです。
デフォルト値はselfの設定のままです。 otherがハッシュではない場合、otherのメソッドto_hashを使って暗黙の変換を試みます。
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!
values -> [object][permalink][rdoc]ハッシュの全値の配列を返します。
h1 = { "a" => 100, 2 => ["some"], :c => "c" }
p h1.values #=> [100, ["some"], "c"]
values_at(*keys) -> [object][permalink][rdoc]引数で指定されたキーに対応する値の配列を返します。
キーに対応する要素がなければデフォルト値が使用されます。
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