Hash クラス

　　ハッシュテーブル（連想配列とも呼ぶ）のクラスです．ハッシュによって，任意の種類のオブジェクト（キー）と，任意の種類のオブジェクト（値）とを関連づけることができます．つまり，「キー」を与えることによって，関連づけられた「値」を知ることができるわけです．ハッシュ生成は，以下のようなハッシュ式で行われます．: { a => b, ･･･ }
　　ハッシュの格納に用いられるハッシュ値の計算には，Object クラスの hash メソッドが使われ，キーの同一性判定には，eql? メソッドが使われます．
　　キーとして与えたオブジェクトの内容が変化し，メソッド hash の返す値が変わると，ハッシュから値が取り出せなくなりますから，Array クラスや Hash クラスなどのインスタンスは，キーに向きません．文字列をキーとして与える場合，文字列をコピーし，コピーを更新不可に設定（ freeze ）し，キーとして使用します．

［インクルードモジュール］ Enumerable モジュール
［クラスメソッド］ Hash　Hash の生成 new　空の Hash の生成
［メソッド］ [key]　キーを指定し値を返す [key]=value　キーと値の関連づけ store　キーと値の関連づけ clear　ハッシュの中身を空にする clone　ハッシュの複製 dup　ハッシュの複製 default　デフォルト値の出力 default=value　デフォルト値の設定 default_proc　デフォルト値を返すブロック delete　キーに関連づけられた値の削除 reject　要素の削除 delete_if　要素の削除 reject!　要素の削除 each　キーと値の対をブロックで評価 each_pair　キーと値の対をブロックで評価 each_key　キーをブロックで評価 each_value　値をブロックで評価 empty?　ハッシュが空か？ fetch　キーに関連づけられた値 has_key?　キーが存在？ include?　キーが存在？ key?　キーが存在？ member?　キーが存在？ has_value?　値が存在？ value?　値が存在？ keys　キーの配列 length　要素数 size　要素数 merge　マージ merge!　マージ update　マージ to_a　配列に変換 values　値の配列 values_at　指定したキーに対応する値の配列

［クラスメソッド］

Hash [ key, value, ･･･ ]
Hash [ hash ]

　　新しいハッシュを生成します．一番目の形式では，引数は必ず偶数個指定しなければなりません（奇数番目がキー，偶数番目が値）．

　　二番目の形式（ 1 つのハッシュオブジェクトを引数に指定した場合）は，指定したハッシュと同一のキーと値を持つ新たなハッシュを生成して返します．

　　以下は，配列からハッシュを生成する方法の例です．3 番目の例では，Enumerable モジュールの zip メソッド，及び，Array クラスの flatten メソッドを利用しています．
```
$KCODE = "SJIS"
print "     定義\n"
h = {1 => "a", 2 => "b", 3 => "c"}
p h
print "     配列の利用（ *x は，配列を展開）\n"
p Hash[1, "a", 2, "b", 3, "c"]
x = [1, "a", 2, "b", 3, "c"]
p Hash[*x]
print "     キーと値の配列利用\n"
k = [1, 2, 3]
v = ["a", "b", "c"]
p x = k.zip(v)
p Hash[*x.flatten]
		
```
（出力）
```
     定義
{1=>"a", 2=>"b", 3=>"c"}
     配列の利用（ *x は，配列を展開）
{1=>"a", 2=>"b", 3=>"c"}
{1=>"a", 2=>"b", 3=>"c"}
     キーと値の配列利用
[[1, "a"], [2, "b"], [3, "c"]]
{1=>"a", 2=>"b", 3=>"c"}		
```
Hash.new ( [ ifnone ] )
Hash.new { |hash, key| ･･･ }

　　空の新しいハッシュを生成します．ifnone は，キーに対応する値が存在しない時のデフォルト値です．ブロックを指定した場合は，ブロックの評価結果がデフォルト値になります．値が設定されていないハッシュ要素を参照すると，その都度ブロックを実行し，その結果を返します．ブロックには，そのハッシュとハッシュを参照したときのキーが渡されます．
```
h = Hash.new("Not Exist")
p h[1]   # "Not Exist" を出力
h = Hash.new { |hash, key| if key < 5 then hash[key] = "small" else hash[key] = "big" end }
p h[1]   # "small" を出力
p h[7]   # "big" を出力		
```

［メソッド］

self [ key ]

　　key に関連づけられた値を返します．該当するキーが登録されていない時には，デフォルト値（設定されていない時には nil ）を返します．
```
h = {1 => "a", 2 => "b", 3 => "c"}
p h[2]   # => "b"		
```
self[key]=value

store ( key, value )

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

h = {1 => "a", 2 => "b", 3 => "c"}
p h[4] = "d"   # => "d"
p h   # => {1=>"a", 2=>"b", 3=>"c", 4=>"d"}
p h[1] = "f"   # => "f"
p h   # => {1=>"f", 2=>"b", 3=>"c", 4=>"d"}

clear
　　ハッシュの中身を空にします．self を返します．

clone
dup
　　同じ内容を持つ新しいハッシュを返します．フリーズ（ freeze ）したハッシュの clone は，同様にフリーズされたハッシュを返しますが，dup は，内容の等しいフリーズされていないハッシュを返します．
default ( [ key ] )

　　ハッシュのデフォルト値を返します．key の指定は，ハッシュがデフォルト値としてブロックを持つ場合に可能です．self と引数 key を引数としてブロックを実行し，その結果を返します．
h = Hash.new("Not Exist") p h.default # "Not Exist" を出力 h = Hash.new { |hash, key| if key < 5 then hash[key] = "small" else hash[key] = "big" end } p h.default(1) # "small" を出力 p h.default(7) # "big" を出力
default = value

　　ハッシュのデフォルト値を value に設定します．対応する値が存在しないキーで検索した時には，この値を返します．
h = Hash.new("Not Exist") p h[1] # => "Not Exist" h.default = nil p h[1] # => nil
default_proc

　　ハッシュのデフォルト値を返す Proc クラスのオブジェクトを返します．デフォルトの Proc を持たない場合 nil を返します．
h = Hash.new { |hash, key| if key < 5 then hash[key] = "small" else hash[key] = "big" end } p h.default_proc # => #<Proc:0x02840768@test.rb:1>
delete ( key )
delete ( key ) { |key| ･･･ }

　　key に関連づけられた値を除きます．取り除かれた値を返しますが，それが存在しない時には nil を返します．ブロックが与えられた時には，key にマッチするものがなかった時に評価し，その結果を返します．
h = {1 => "a", 2 => "b", 3 => "c"} p h.delete(2) # => "b" p h # => {1=>"a", 3=>"c"} p h.delete(2) { |m| "Not Exist" } # => "Not Exist"
reject { | key, value | ･･･ }

　　self を複製して，ブロックを評価した値が真になる要素を削除したハッシュを返します．
h = {1 => "a", 2 => "b", 3 => "b", 4 => "d"} p h.reject { |key, value| key > 2 && value == "b" } # => {1=>"a", 2=>"b", 4=>"d"} p h # => {1=>"a", 2=>"b", 3=>"b", 4=>"d"}
delete_if { | key, value | ･･･ }
reject! { | key, value | ･･･ }

　　key と value を引数として，ブロックを評価した値が真である時，その要素を self から削除します．delete_if は，常に self を返します．reject! は，要素を削除しなかった場合には nil を返し，そうでなければ self を返します．
h = {1 => "a", 2 => "b", 3 => "b", 4 => "d"} p h.delete_if { |key, value| key > 2 && value == "b" } # => {1=>"a", 2=>"b", 4=>"d"} >p h # => {1=>"a", 2=>"b", 4=>"d"}
each { | key, value | ･･･ }
each_pair { | key, value | ･･･ }

　　key と value を引数として，ブロックを評価します．self を返します．
h = {1 => "a", 2 => "b", 3 => "b", 4 => "d"} $count = 0 h.each { |key, value| if value == "b" then $count += 1 end } p $count # => 2
each_key { | key | ･･･ }

　　key を引数としてブロックを評価します．self を返します．
h = {1 => "a", 2 => "b", 3 => "b", 4 => "d"} $count = 0 h.each_key { |key| if key > 2 then $count += 1 end } p $count # => 2
each_value { | value | ･･･ }

　　value を引数としてブロックを評価します．self を返します．
h = {1 => "a", 2 => "b", 3 => "b", 4 => "d"} $count = 0 h.each_value { |value| if value == "b" then $count += 1 end } p $count # => 2
empty?

　　ハッシュが空の時，真を返します．

fetch ( key [ , default ] )
fetch ( key ) { | key | ･･･ }

　　key に関連づけられた値を返します．該当するキーが登録されていない時には，引数 default が与えられていればその値を，ブロックが与えられていればそのブロックを評価した値を返します．そのいずれでもなければ，例外 IndexError が発生します．
h = {1 => "a", 2 => "b", 3 => "b"} p h.fetch(2) # => "b" p h.fetch(4) { |key| "Not Exist" } # => "Not Exist"

has_key? ( key )
include? ( key )
key? ( key )
member? ( key )

　　ハッシュが key をキーとして持つ時，真を返します
h = {1 => "a", 2 => "b", 3 => "b"} p h.has_key?(2) # => true p h.has_key?(4) # => false

has_value? ( value )
value? ( value )

　　ハッシュが value を値として持つ時，真を返します．値の一致判定は，== で行われます．
h = {1 => "a", 2 => "b", 3 => "b"} p h.has_value?("b") # => true p h.has_value?("c") # => false

keys

　　すべてのキーの配列を返します（ values 参照）．
h = {1 => "a", 2 => "b", 3 => "c"} p h.keys # => [1, 2, 3]

length
size

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

merge ( other )
merge ( other ) { | key, self_val, other_val | ･･･ }
merge! ( other )
update ( other )
merge! ( other ) { | key, self_val, other_val | ･･･ }
update ( other ) { | key, self_val, other_val | ･･･ }

　　ハッシュの内容をマージします．重複するキーに対応する値は，other の内容で上書きされます．ブロックが与えられた場合は，重複するキーごとにブロックを評価して，その結果をそのキーに対応する値にします．merge は，self をコピーした内容をマージして返しますが，merge! と update は，self をマージして self を返します．
h1 = {1 => "a", 2 => "x"} h2 = {2 => "y", 3 => "c"} p h1.merge(h2) # => {1=>"a", 2=>"y", 3=>"c"} p h1.merge(h2) { |key, v1, v2| v1 } # => {1=>"a", 2=>"x", 3=>"c"}

to_a

　　[ key, value ] からなる 2 要素の配列の配列を生成して返します．
h1 = {1 => "a", 2 => "x"} p h1.to_a # => [[1, "a"], [2, "x"]]

values

　　すべての値の配列を返します（ keys 参照）．
h = {1 => "a", 2 => "b", 3 => "c"} p h.values # => ["a", "b", "c"]

values_at ( key_1, ･･･, key_n )

　　引数で指定されたキーに対応する値の配列を返します．
h = {1 => "a", 2 => "b", 3 => "c"} p h.values_at(1, 3) # => ["a", "c"]

情報学部

菅沼ホーム

索引