Ruby Hash类

在Ruby中， Hash 是一个唯一键和它们的值的集合。Hash就像一个数组，只是索引是在任何对象类型的任意键的帮助下完成的。在Hash中，通过各种迭代器返回键和它们的值的顺序是任意的，通常不会按照插入的顺序。哈希的默认值是 nil。 当用户试图访问不存在于哈希中的键时，就会返回 nil值。

类方法

1.[] : 这个方法创建一个新的哈希，用给定的对象填充。它等同于使用字面意思{Key=>value….}创建一个哈希。键和值都是成对存在的，所以有偶数个参数存在。

Hash[(key=>value)*]

例子

# Ruby program to illustrate
# use of []
# Using []
p Hash["x", 30, "y", 19]
p Hash["x" => 30, "y" => 19]

输出

{"x"=>30, "y"=>19}
{"x"=>30, "y"=>19}

2. new : 该方法返回一个空的哈希值。如果一个哈希值随后被与哈希条目不匹配的键访问，该方法返回的值取决于用于创建哈希的 new 的样式。在第一种形式下，访问返回 nil。 如果指定了 obj ，那么这个对象将用于所有的默认值。如果指定了一个块，那么它将被哈希键和对象所调用并返回默认值。值被存储在哈希中（如果需要）取决于块。

Hash.new
Hash.new(obj)
Hash.new{|hash, key|block}

例子

# Ruby program to illustrate
# use of new method
 
# Using new method
a = Hash.new("geeksforgeeks")
p a["x"] = 40
p a["y"] = 49
p a["x"]
p a["y"]
p a["z"]

输出

40
49
40
49
"geeksforgeeks"

3.try_convert : 该方法用于将 obj 转换成hash，并返回hash或nil。当 obj 没有转换为哈希值时，它返回nil。

Hash.try_convert(obj)

例子

# Ruby program to illustrate
# use of try_convert method
 
# Using try_convert method
p Hash.try_convert({3=>8})
p Hash.try_convert("3=>8")

输出

{3=>8}
nil

实例方法

注意： 在下面描述的方法中， hsh 变量是哈希类的实例。

1.==： 它被称为平等性。它用于检查两个哈希值是否相等。如果它们相等意味着它们包含相同数量的键，并且与这些键相关的值相等，那么它将返回真，否则返回假。

hsh1 == hsh2

例子

# Ruby program to illustrate
# use of Equality
 
a1 = {"x" => 4, "y" => 109}
a2 = {"x" => 67, "f" => 78, "z" => 21}
a3 = {"f" => 78, "x" => 67, "z" => 21}
 
# Using equality
p a1 == a2
p a2 == a3

输出

false
true

2.[] : 它被称为元素参考。它检索存储在键中的值。如果它没有找到任何值，它将返回默认值。

hsh[key]

例子

# Ruby program to illustrate
# use of []
 
a = {"x" => 45, "y" => 67}
 
# Using []
p a["x"]
p a["z"]

输出

45
nil

3.[]= : 它被称为元素赋值。它将value给定的值与key给定的键联系起来。

hsh[key]=value

例子

# Ruby program to illustrate
# use of []=
 
a = {"x" => 45, "y" => 67}
 
# Using []=
a["x"]= 34
a["z"]= 89
p a

输出

{"x"=>34, "y"=>67, "z"=>89}

4.清除： 该方法从hsh中删除所有的键和它们的值。

hsh.clear

例子

# Ruby program to illustrate
# use of clear method
 
a = {"x" => 45, "y" => 67}
 
# Using clear method
p a.clear

输出

{}

5. default : 该方法返回默认值。如果hsh中不存在key，则返回hsh[key]的值。

hsh.default(nil=key)

例子

# Ruby program to illustrate
# use of default method
 
a = Hash.new("geeksforgeeks")
 
# Using default method
p a.default
p a.default(2)

输出

"geeksforgeeks"
"geeksforgeeks"

6. default= : 该方法设置默认值（为一个键返回的值，不存在于哈希中）。

hsh.default=obj

7.default_proc : 在这个方法中，如果Hash.new被调用时带有块。那么它将返回block，否则返回nil。

hsh.default_proc

例子

# Ruby program to illustrate
# use of default_proc method
 
a = Hash.new {|a, v| a[v] = v*v*v}
 
# Using default_proc method
b = a.default_proc
c = []
p b.call(c, 2)
p c

输出

8
[nil, nil, 8]

8.delete : 该方法用于从哈希中删除键为key的条目，并返回相应的值。如果没有找到键，那么该方法返回nil。如果给定了可选的块并且没有找到键，那么它将传递块并返回块的结果。

hsh.delete(key)
hsh.delete(key){|key|block}

例子

# Ruby program to illustrate
# use of delete method
 
a = {"x" => 34, "y" => 60}
 
# Using delete method
p a.delete("x")
p a.delete("z")

输出

34
nil

9. delete_if : 当区块为真时，该方法将键和它们的值从hsh中删除。

hsh.delete_if{|key, value|block}

例子

# Ruby program to illustrate
# use of delete_if method
 
a = {"x" => 34, "y" => 60}
 
# Using delete_if method
p a.delete_if {|key, value| key >= "y"}

输出

{"x"=>34}

10.each： 该方法对hsh中的每个键都调用一次块，并将键和值作为参数传递。

hsh.each{|key, value|block}

例子

# Ruby program to illustrate
# use of each method
 
a = {"x" => 34, "y" => 60}
 
# Using each method
a.each {|key, value| puts  "the value of #{key} is #{value}" }

输出

the value of x is 34
the value of y is 60

each_key : 这个方法对hsh中存在的每一个键都调用一次块，并将键作为一个参数传递。

hsh.each_key{|key|block}

例子

# Ruby program to illustrate
# use of each_key method
 
a = { "x" => 34, "y" => 60 }
 
# Using the each_key method
a.each_key {|key| puts key }

输出

x
y

12. each_pair : 这个方法类似于Hash#each方法。

hsh.each_pair{|key, value|block}

each_value : 这个方法对hsh中的每一个键都调用一次块，并将值作为参数传递。

hsh.each_key{|value|block}

例子

# Ruby program to illustrate
# use of each_value method
 
# Using each_value method
a = { "g" => 23, "h" => 25, "x"=>3432, "y"=>3453, "z"=>676 }
a.each_value{|value| puts value }

输出

14.empty? : 如果hsh不包含任何键和值对，该方法返回true。否则，返回false。

hsh.empty?

15. fetch : 这个方法使用给定的键从hsh中返回一个值。如果没有找到键，那么它给出的结果将取决于以下条件。

如果没有参数，那么它将引发一个异常。
如果给出了默认值，它将返回默认值。
如果有一个选项块存在，那么它将运行该块并返回该块的结果。

fetch方法不包含任何默认值。当哈希值被创建时，它将只关注哈希值中存在的键。

hsh.fetch(key[, default])
hsh.fetch(key){|key|block}

16.has_key? : 如果给定的密钥存在于hsh中，该方法返回true，否则，返回false。

hsh.has_key?

例子

# Ruby program to illustrate
# use of has_key? method
 
a = {"g" => 23, "h" => 25, "x"=>3432, "y"=>3453, "z"=>676}
 
# Using has_key? method
p a.has_key?("x")
p a.has_key?("p")

输出

true
false

has_value? : 如果hsh中的某个键存在给定的值，该方法返回true，否则，返回false。

hsh.has_value?

例子

# Ruby program to illustrate
# use of has_value? method
 
a = { "g" => 23, "h" => 25, "x"=>3432, "y"=>3453, "z"=>676 }
 
# Using has_value? method
p a.has_value?(23)
p a.has_value?(234)

输出

true
false

18.include? : 这个方法与Hash#has_key?方法类似。

hsh.include?

index : 该方法返回包含给定值的键。如果多个键包含给定的值，那么它将只返回所有键中的一个键，如果没有找到则返回nil。这是一个废弃的方法。所以我们必须使用 Hash#key 来代替。

hsh.index(value)

invert : 该方法返回一个由hsh’s values作为key，key作为value创建的新的哈希值。如果发现有重复的值，那么它将只包含所有值中的一个值作为键。

hsh.invert

例子

# Ruby program to illustrate
# use of invert method
 
a = { "g" => 23, "h" => 25, "x"=>3432, "y"=>3453, "z"=>676 }
 
# Using invert method
p a.invert

输出

{23=>"g", 25=>"h", 3432=>"x", 3453=>"y", 676=>"z"}

21.key? : 这个方法类似于Hash#has_key? 。

hsh.key?(key)

22.keys： 该方法返回哈希中存在的键的数组。

hsh.keys

length : 该方法返回hsh.com中键和值对的数量。

hsh.length

例子

# Ruby program to illustrate
# use of length method
 
a = {"g" => 23, "h" => 25}
 
# Using the length method
p a.length

输出

24. member? : 这个方法类似于Hash#has_key? 。

hsh.member?(key)

merge : 该方法返回包含其他hsh内容的新hash。如果指定了一个块，那么每个重复的键和它们的值都会从哈希值和存储在新的哈希值中调用。

hsh.merge(other_hsh)
hsh.merge(other_hsh){|key, old_value, new_value|block}

例子

# Ruby program to illustrate
# use of merge method
 
a1 = { "g" => 23, "h" => 25 }
a2 = { "h" => 2343, "i" => 4340 }
 
# Using merge method
p a1.merge(a2)

输出

 {"g"=>23, "h"=>2343, "i"=>4340}

26. merge!： 该方法将一个hsh的内容合并到另一个hsh中，并且用其他hsh中的重复键覆盖那些条目。

hsh.merge!(other_hsh)
hsh.merge!(other_hsh){|key, old_value, new_value|block}

例子

# Ruby program to illustrate
# use of merge! method
 
a1 = {"g" => 23, "h" => 25}
a2 = {"h" => 2343, "i" => 4340}
 
# Using merge! method
p a1.merge!(a2)
 
a1 = {"g" => 23, "h" => 25 }
 
# Using merge! method
p a1.merge!(a2) {|x, y, z| y}
p a1

输出

{"g"=>23, "h"=>2343, "i"=>4340}
{"g"=>23, "h"=>25, "i"=>4340}
{"g"=>23, "h"=>25, "i"=>4340}

27. rehash : 该方法根据每个键的当前哈希值重新创建哈希。如果键的哈希值改变了，那么它将重新索引hsh。

hsh.rehash

例子

# Ruby program to illustrate
# use of rehash method
 
x = [ "x", "g" ]
y = [ "y", "f" ]
a = { x => 45345, y => 6756 }
p a[x]
p x[0] = "h"
p a[x]
 
# Using rehash method
p a.rehash
p a[x]

输出

45345
"h"
nil
{["h", "g"]=>45345, ["y", "f"]=>6756}
45345

28. reject : 这个方法类似于Hash#delete_if，但是它返回hsh的副本。

hsh.reject{|key, value|block}

29. reject!： 该方法与Hash#delete_if类似，但如果没有发生变化，则返回nil。

hsh.reject!{|key, value|block}

replace : 该方法从其他hsh中替换hsh的内容。

hsh.replace(other_hsh)

例子

# Ruby program to illustrate
# use of replace method
 
a = { "x" => 34, "y" => 60, "z"=>33 }
 
# Using replace method
p a.replace({ "y" => 88, "x" => 987 })

输出

{"y"=>88, "x"=>987}

31.选择： 该方法返回一个新的数组，该数组仅由一个键和值对组成，其中块中的给定条件为真。

hsh.select{|key, value| block}

例子

# Ruby program to illustrate
# use of select method
 
a = { "x" => 34, "y" => 60, "z"=>33 }
 
# Using select method
p a.select {|g, f| g > "x"}

输出

{"y"=>60, "z"=>33}

shift : 这个方法从 hsh 中删除键和值对，并将它们作为一个双项数组返回。如果hsh不包含任何一对，则返回nil。

hsh.shift

例子

# Ruby program to illustrate
# use of shift method
 
a = { "x" => 34, "y" => 60, "z"=>33 }
 
# Using the shift method
p a.shift
p a

输出

["x", 34]
{"y"=>60, "z"=>33}

33. size : 这个方法与Hash#length类似。

hsh.size

sort : 该方法将hsh转换为包含键和其值的嵌套数组，并通过Array#sort对其进行排序。

hsh.sort
hsh.sort{|a, b|block}

例子

# Ruby program to illustrate
# use of sort method
 
a = { "x" => 34, "y" => 60, "z"=>33 }
 
# Using sort method
p a.sort
p a.sort {|x, y| x[1]<=>y[1]}

输出

[["x", 34], ["y", 60], ["z", 33]]
[["z", 33], ["x", 34], ["y", 60]]

35.存储： 该方法与Hash#[]=类似。

hsh.store(key, value)

to_a : 该方法将HSH转换为包含键和其值的嵌套数组。

hsh.to_a

例子

# Ruby program to illustrate
# use of to_a method
 
a = { "x" => 34, "y" => 60, "z"=>33 }
 
# Using to_a method
p a.to_a

输出

[["x", 34], ["y", 60], ["z", 33]]

to_s : 该方法将hsh转换为字符串。换句话说，它将哈希数组，即键和值对转换为一个字符串。

hsh.to_s

38.更新： 这个方法类似于Hash#merge！。

hsh.update(other_hsh)
hsh.update(other_hsh){|key, old_value, new_value|block}

39. value? : 这个方法类似于Hash#has_value? 。

hsh.value?(value)

values : 该方法返回一个数组，其中包含hsh中的值。

hsh.values

values_at : 该方法返回一个数组，其中包含指定键的值，同时也为没有找到的键提供默认值。

hsh.values_at([keys])

例子

# Ruby program to illustrate
# use of values_at method
 
a = {"x" => 34, "y" => 60, "z"=>33}
 
# Using values_at method
p a.values_at("x", "y")
 
# Using default method
a.default = "geeks"
 
# Using values_at method
p a.values_at("x", "y", "z", "g")

输出