1.简介
2.安装
3.基本语法
4高级进阶
------继续
3.基本语法
3.12 Arrays 数组
Ruby 数值是有序的，整数为索引的任何对象集合。数组中的每个元素与索引关联使用。
和C或Java 一样， 数组索引从0开始。负的索引被看作从数组尾部开始。-1代表数组最后的元素，-2代表倒数第二个元素，等等。
Ruby 数组可以容纳String, Integer,Hash, Symbol,甚至数组对象。 Ruby arrays数组不像其它语言那么严格，增加元素的时候自动增长。
3.12.1 Creating Arrays 创建数组
创建数组的方法很多。 一种是使用类方式new：
names = Array.new
创建时可以设置数组大小
names = Array.new(20)
可以用 size 或 length 方法返回数组大小
#!/usr/bin/ruby
names = Array.new(20)
puts names.size # This returns 20
puts names.length # This also returns 20
执行结果：
20
20
可以如下创建数组的时候给数组赋值
#!/usr/bin/ruby
names = Array.new(4, "mac")
puts "#{names}"
数组如下
["mac", "mac", "mac", "mac"]
你可以用块的值来填充new 的数组
#!/usr/bin/ruby
nums = Array.new(10) { |e| e = e * 2 }
puts "#{nums}"
注意，这儿的e是索引值，你可以自己修改表达式观察。结果如下：
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
也可以用Array.[]来创建数组
nums = Array.[](1, 2, 3, 4,5)
另外一种方式，直接在[]内赋值建立数组
nums = Array[1, 2, 3, 4,5]
Ruby的Kernel模块有种数组方式，只接受一个参数，范围，用来传教数字数组(array of digits)。
#!/usr/bin/ruby
digits = Array(0..9)
puts "#{digits}"
结果
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
3.12.2 Array Built-in Methods 数组内置方法
创建数组实例的方法
Array.[](...) [or] Array[...] [or] [...]
这将返回异常用给定对象填充的新数组。 用创建的数组，可以调用任何实例方法。
#!/usr/bin/ruby
digits = Array(0..9)
num = digits.at(6)
puts "#{num}"
结果
6
进一步具体的，可以查看官方文档。
3.12.3 Array pack Directives 数组打包指令
简明教程不具体讲。举几个例子
a = [ "a", "b", "c" ]
n = [ 65, 66, 67 ]
puts a.pack("A3A3A3") #=> "a b c "
puts a.pack("a3a3a3") #=> "a\000\000b\000\000c\000\000"
puts n.pack("ccc") #=> "ABC"
结果如下。
a b c
abc
ABC
3.13 Hash 哈希
注意：hash 内容来自 ruby 2.6.5. 如果运行代码有问题，请安装ruby2.6.5。或者理解有关内容，修改代码。
Hash 是类似字典的集合，包含的键值唯一，每个键有对应的值。也叫做关联数组，不过数组的索引是整数，而Hash允许用任何对象类型。
Hashe 遍历根据键的插入顺序来遍历对应的值。可以用隐含形式创建Hash
grades = { "Jane Doe" => 10, "Jim Doe" => 6 }
对于符号类型的键，可以用：而不是=>
options = { :font_size => 10, :font_family => "Arial" }
可以如下
options = { font_size: 10, font_family: "Arial" }
每个命名的键，你都可以访问E
options[:font_size] # => 10
Hash 可以用它的 ::new 方式创建：
grades = Hash.new
grades["Dorothy Doe"] = 9
Hash 对不存在的键可以设置一个缺省值。如果没有设置，则用nil。 可以给::new传参来设置这个值。
grades = Hash.new(0)
也可以使用 default=方法
grades = {"Timmy Doe" => 8}
grades.default = 0
Hash 需要通过键来访问值。
puts grades["Jane Doe"] # => 0
3.13.1 Common Uses 通常用法
hash 表示数据结构
books = {}
books[:matz] = "The Ruby Programming Language"
books[:black] = "The Well-Grounded Rubyist"
Hashe 让函数具有命名的参数。如果hash 是方法调用的最后参数，则不需要括号，界面清洁。
Person.create(name: "John Doe", age: 27)
def self.create(params)
@name = params[:name]
@age = params[:age]
end
3.13.2 Hash Keys 键
Two objects refer to the same hash key when their hash value is identical and the two objects are eql? to each other.
俩个对象的hash 值一致并且互相eql?, 那么它们指向同一个hash key。
用户自定义的类可以作为hash key, 如果hash ,eql? 被重写。默认情况，不同的实例指向不同hash keys.
典型的实现，hash 基于对象数据，而 eql? 是重写方法的别名。
class Book
attr_reader :author, :title
def initialize(author, title)
@author = author
@title = title
end
def ==(other)
self.class === other and
other.author == @author and
other.title == @title
end
alias eql? ==
def hash
@author.hash ^ @title.hash # XOR
end
end
book1 = Book.new 'matz', 'Ruby in a Nutshell'
book2 = Book.new 'matz', 'Ruby in a Nutshell'
reviews = {}
reviews[book1] = 'Great reference!'
reviews[book2] = 'Nice and compact!'
reviews.length #=> 1
3.13.3 Public Class Methods 公共类方法
Hash[ key, value, ... ] → new_hash
Hash[ [ [key, value], ... ] ] → new_hash
Hash[ object ] → new_hash
以上格式，创建填充了给定对象的新 hash。
与 { key => value, ... }类似. 第一种格式键值成对出现，参数是偶数 。
第二三种方式单个参数，参数是键值对数组或可以转换为hash的对象。
Hash["a", 100, "b", 200] #=> {"a"=>100, "b"=>200}
Hash[ [ ["a", 100], ["b", 200] ] ] #=> {"a"=>100, "b"=>200}
Hash["a" => 100, "b" => 200] #=> {"a"=>100, "b"=>200}
new → new_hash
new(obj) → new_hash
new {|hash, key| block } → new_hash
以上创建新的hash .
h = Hash.new("Go Fish")
h["a"] = 100
h["b"] = 200
h["a"] #=> 100
h["c"] #=> "Go Fish"
# The following alters the single default object
h["c"].upcase! #=> "GO FISH"
h["d"] #=> "GO FISH"
h.keys #=> ["a", "b"]
# While this creates a new default object each time
h = Hash.new { |hash, key| hash[key] = "Go Fish: #{key}" }
h["c"] #=> "Go Fish: c"
h["c"].upcase! #=> "GO FISH: C"
h["d"] #=> "Go Fish: d"
h.keys #=> ["c", "d"]
try_convert(obj) → hash or nil
试图将 obj 转换成 hash,使用 #to_hash 方法. 返回转换的 hash 或 nil 如果不成功。
Hash.try_convert({1=>2}) # => {1=>2}
Hash.try_convert("1=>2") # => nil
3.13.4 Public Instance Methods 公共实例方法
hash < other → true or false
小于。如果hash 是other的子集，返回true， 否则false。
h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 < h2 #=> true
h2 < h1 #=> false
h1 < h1 #=> false
hash <= other → true or false
小于等于。如果hash 是other的子集或全集，返回true， 否则false
h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 <= h2 #=> true
h2 <= h1 #=> false
h1 <= h1 #=> true
hsh == other_hash → true or false
相等。俩个hash 相等如果他们含有同样数目的键，并且对应的每个键值对都相当 (根据对象#==)
h1 = { "a" => 1, "c" => 2 }
h2 = { 7 => 35, "c" => 2, "a" => 1 }
h3 = { "a" => 1, "c" => 2, 7 => 35 }
h4 = { "a" => 1, "d" => 2, "f" => 35 }
h1 == h2 #=> false
h2 == h3 #=> true
h3 == h4 #=> false
Hash 的顺序不比较。
h1 = { "a" => 1, "c" => 2 }
h2 = { "c" => 2, "a" => 1 }
h1 == h2 #=> true
hash > other → true or false
大于。 如果 other 是 hash的子集。
h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 > h2 #=> false
h2 > h1 #=> true
h1 > h1 #=> false
hash >= other → true or false
大于等于。判断 other 是 hash 的全集或子集。
h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 >= h2 #=> false
h2 >= h1 #=> true
h1 >= h1 #=> true
hsh[key] → value
元素引用。获取键对应的值。如果找不到，返回缺省值。
h = { "a" => 100, "b" => 200 }
h["a"] #=> 100
h["c"] #=> nil
3.13.5 Element Assignment 元素赋值
h = { "a" => 100, "b" => 200 }
h["a"] = 9
h["c"] = 4
h #=> {"a"=>9, "b"=>200, "c"=>4}
h.store("d", 42) #=> 42
h #=> {"a"=>9, "b"=>200, "c"=>4, "d"=>42}
键key用做键的时候，它的值是不能改变的。（未冻结的String传做Key的时候，会复制一份并冻结来作为键）
a = "a"
b = "b".freeze
h = { a => 100, b => 200 }
h.key(100).equal? a #=> false
h.key(200).equal? b #=> true
any? [{ |(key, value)| block }] → true or false
any?(pattern) → true or false
使用==比较Obj和key，搜索hash.找到返回键值对，否则返回nil.
h = {"colors" => ["red", "blue", "green"],
"letters" => ["a", "b", "c" ]}
h.assoc("letters") #=> ["letters", ["a", "b", "c"]]
h.assoc("foo") #=> nil
clear → hsh
清除hash中的键值对。
h = { "a" => 100, "b" => 200 } #=> {"a"=>100, "b"=>200}
h.clear #=> {}
compact → new_hash
返回一个清除nil键值对后的新hash.
h = { a: 1, b: false, c: nil }
h.compact #=> { a: 1, b: false }
h #=> { a: 1, b: false, c: nil }
compact! → hsh or nil
清除hash中的所有nil值。 如果没有改变，返回nil；否则，返回清除后的hash。
h = { a: 1, b: false, c: nil }
h.compact! #=> { a: 1, b: false }
compare_by_identity → hsh
让hash 比较它的key 和identity。将完全相同的对象，看作相同的key.
h1 = { "a" => 100, "b" => 200, :c => "c" }
h1["a"] #=> 100
h1.compare_by_identity
h1.compare_by_identity? #=> true
h1["a".dup] #=> nil # different objects.
h1[:c] #=> "c" # same symbols are all same.
compare_by_identity? → true or false
如果hash 会按照identity 比较key，就返回true 。hash默认为false，执行完compare_by_identity后，compare_by_identity?就返回true.
default(key=nil) → obj
返回key不存在hash返回的缺省值。
h = Hash.new #=> {}
h.default #=> nil
h.default(2) #=> nil
h = Hash.new("cat") #=> {}
h.default #=> "cat"
h.default(2) #=> "cat"
h = Hash.new {|h,k| h[k] = k.to_i*10} #=> {}
h.default #=> nil
h.default(2) #=> 20
default = obj → obj
设置键不存在时hash返回的缺省值。不可能将缺省值设置为Proc。
h = { "a" => 100, "b" => 200 }
h.default = "Go fish"
h["a"] #=> 100
h["z"] #=> "Go fish"
# This doesn't do what you might hope...
h.default = proc do |hash, key|
hash[key] = key + key
end
h[2] #=> #<Proc:0x401b3948@-:6>
h["cat"] #=> #<Proc:0x401b3948@-:6>
default_proc → anObject
如果 Hash::new 被块调用，就返回调用块，否则返回nil。
h = Hash.new {|h,k| h[k] = k*k } #=> {}
p = h.default_proc #=> #<Proc:0x401b3d08@-:1>
a = [] #=> []
p.call(a, 2)
a #=> [nil, nil, 4]
default_proc = proc_obj or nil
设置找不到键时执行的缺省proc。
h.default_proc = proc do |hash, key|
hash[key] = key + key
end
h[2] #=> 4
h["cat"] #=> "catcat"
delete(key) → value
delete(key) {| key | block } → value
删除键值对并返回key对应的值。如果没有找到key，返回nil。如果可选项block给定，而且key没有找到，传入参数，并返回block结果。I
h = { "a" => 100, "b" => 200 }
h.delete("a") #=> 100
h.delete("z") #=> nil
h.delete("z") { |el| "#{el} not found" } #=> "z not found"
delete_if {| key, value | block } → hsh
delete_if → an_enumerator
删除block为true对应键值对。
If no block is given, an enumerator is returned instead. 如果没有给定块，则返回一个枚举器。
h = { "a" => 100, "b" => 200, "c" => 300 }
h.delete_if {|key, value| key >= "b" } #=> {"a"=>100}
dig(key, ...) → object
抽取key对象序列指定的嵌套值, 任何一步遇到nil返回nil.
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
g.dig(:foo, 1, 0) #=> TypeError: Integer does not have #dig method
g.dig(:foo, :bar) #=> TypeError: no implicit conversion of Symbol into Integer
each {| key, value | block } → hsh
each → an_enumerator
对应hash中的每个key,将键值对传入block, 执行一次。
如果没有指定块，返回一个枚举器。
h = { "a" => 100, "b" => 200 }
h.each {|key, value| puts "#{key} is #{value}" }
结果：
a is 100
b is 200
each_key {| key | block } → hsh
each_key → an_enumerator
对应每个key , 传给block并执行一次。
如果没有指定块，则返回枚举器。
h = { "a" => 100, "b" => 200 }
h.each_key {|key| puts key }
结果
a
b
each_pair {| key, value | block } → hsh
each_pair → an_enumerator
对应hash中的每个将键值对传入block, 执行一次。
如果没有指定块，返回一个枚举器。
h = { "a" => 100, "b" => 200 }
h.each_pair {|key, value| puts "#{key} is #{value}" }
produces:
a is 100
b is 200
each_value {| value | block } → hsh
each_value → an_enumerator
对应每个value , 传给block并执行一次。
如果没有指定块，则返回枚举器。
h = { "a" => 100, "b" => 200 }
h.each_value {|value| puts value }
produces:
100
200
empty? → true or false
检查hash 是否是空的。.
{}.empty? #=> true
eql?(other) → true or false
判断hash和other是否对同样的内容哈希。 每个哈希的顺序不比较。
fetch(key [, default] ) → obj
fetch(key) {| key | block } → obj
获取hash给定key对应的value。如果key没有找到的情况：如果没有其它参数，keyError 异常； 如果给定缺省值，返回缺省值；如果可选项block 指定，将执行代码并返回结果。
h = { "a" => 100, "b" => 200 }
h.fetch("a") #=> 100
h.fetch("z", "go fish") #=> "go fish"
h.fetch("z") { |el| "go fish, #{el}"} #=> "go fish, z"
下例抛出异常，如果key没有找到且没有提供缺省值。
h = { "a" => 100, "b" => 200 }
h.fetch("z")
结果
prog.rb:2:in `fetch': key not found (KeyError)
from prog.rb:2
fetch_values(key, ...) → array
fetch_values(key, ...) { |key| block } → array
返回给定key对应值的数组，如果有没有找到的key同事抛出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"]
filter {|key, value| block} → a_hash
filter → an_enumerator
返回block过滤得到新hash。
没有指定block ，则返回枚举器。
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}
filter! {| key, value | block } → hsh or nil
filter! → an_enumerator
等同于 #keep_if, 满足block条件的保留，删除不满足的，但是返回nil 如果hash没有改变。.
flatten → an_array
flatten(level) → an_array
将hash转换成一维数组返回。 不同于Array#flatten, 此方法默认不递归。 可选项level决定递归深度。
a = {1=> "one", 2 => [2,"two"], 3 => "three"}
a.flatten # => [1, "one", 2, [2, "two"], 3, "three"]
a.flatten(2) # => [1, "one", 2, 2, "two", 3, "three"]
has_key?(key) → true or false
检查是hash否包含指定的key ..
h = { "a" => 100, "b" => 200 }
h.has_key?("a") #=> true
h.has_key?("z") #=> false
s_value?(value) → true or false
检查是hash否包含指定的value.
h = { "a" => 100, "b" => 200 }
h.value?(100) #=> true
h.value?(999) #=> false
hash → integer
计算hash的hash-code，返回整数。
include?(key) → true or false
检查hash是否包含指定key 。
h = { "a" => 100, "b" => 200 }
h.has_key?("a") #=> true
h.has_key?("z") #=> false
to_s → string
inspect → string
将hash 内容返回字符串。
h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300 }
h.to_s #=> "{\"c\"=>300, \"a\"=>100, \"d\"=>400}"
invert → new_hash
将键值对互换，生成新的hash返回。如果有重复值的key, 则保留最后的，前面的抛弃。
h = { "n" => 100, "m" => 100, "y" => 300, "d" => 200, "a" => 0 }
h.invert #=> {0=>"a", 100=>"m", 200=>"d", 300=>"y"}
如果key没有重复值, #invert 不卷曲 involutive，即
h = { a: 1, b: 3, c: 4 }
h.invert.invert == h #=> true
可以比较hash 和 互换的hash的大小是否相等来测试是否键值有重复。
# no key with the same value
h = { a: 1, b: 3, c: 4 }
h.size == h.invert.size #=> true
# two (or more) keys has the same value
h = { a: 1, b: 3, c: 1 }
h.size == h.invert.size #=> false
keep_if {| key, value | block } → hsh
keep_if → an_enumerator
删除不满足条件的键值对。
如果没有指定block, 返回枚举器。
key(value) → key
查找value对应的key. 如果找不到，返回nil .
h = { "a" => 100, "b" => 200, "c" => 300, "d" => 300 }
h.key(200) #=> "b"
h.key(300) #=> "c"
h.key(999) #=> nil
key?(key) → true or false
检查指定的key 是否在hash中。
h = { "a" => 100, "b" => 200 }
h.has_key?("a") #=> true
h.has_key?("z") #=> false
keys → array
返回hash中的keys 数组。
h = { "a" => 100, "b" => 200, "c" => 300, "d" => 400 }
h.keys #=> ["a", "b", "c", "d"]
length → integer
返回hash中键值对的个数。
h = { "d" => 100, "a" => 200, "v" => 300, "e" => 400 }
h.size #=> 4
h.delete("a") #=> 200
h.size #=> 3
h.length #=> 3
member?(key) → true or false
检查hash是否有指定的key.
h = { "a" => 100, "b" => 200 }
h.member?("a") #=> true
h.member?("z") #=> false
注意 ： include? 和 member? 不像其它枚举用==来测试相等。
merge(other_hash1, other_hash2, ...) → new_hash
merge(other_hash1, other_hash2, ...) {|key, oldval, newval| block}→ new_hash
将给定hash 和 接收器的内容合并成一个新hash。
如果没有指定block 重复key 的值将被每个other_hash的值覆盖；如果指定block，则重复key的值将被block 的运算值替代。
当没有任何参数，返回接收器的拷贝。
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}
merge!(other_hash1, other_hash2, ...) → hsh
merge!(other_hash1, other_hash2, ...) {|key, oldval, newval| block}
将给定参数的hashes的内容添加到接收者。
如果没有指定block， 有重复键的条目被后来的覆盖；如果指定了block， 重复key的值由block及receiver 和 other_hash 的值来决定。
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}
rassoc(obj) → an_array or nil
Searches through the hash comparing obj with the value using ==. Returns the first key-value pair (two-element array) that matches. See also Array#rassoc.
使用==比较obj和value,搜索hash. 返回第一个匹配的键值对，否则返回nil.
a = {1=> "one", 2 => "two", 3 => "three", "ii" => "two"}
a.rassoc("two") #=> [2, "two"]
a.rassoc("four") #=> nil
rehash → hsh
根据当前每个键的当前hash value 重建hash. 如果键值有改变，将重新索引hash. 当迭代器访问hash的时候，调用Hash#rehash会导致RuntimeError.
a = [ "a", "b" ]
c = [ "c", "d" ]
h = { a => 100, c => 300 }
h[a] #=> 100
a[0] = "z"
h[a] #=> nil
h.rehash #=> {["z", "b"]=>100, ["c", "d"]=>300}
h[a] #=> 100
reject {|key, value| block} → a_hash
reject → an_enumerator
返回不满足block条件的条目组成的新hash。
如果没有block, 返回一个枚举器。
h = { "a" => 100, "b" => 200, "c" => 300 }
h.reject {|k,v| k < "b"} #=> {"b" => 200, "c" => 300}
h.reject {|k,v| v > 100} #=> {"a" => 100}
reject! {| key, value | block } → hsh or nil
reject! → an_enumerator
与Hash#delete_if相同, 但返回nil 如果没有变化。
replace(other_hash) → hsh
Replaces the contents of hsh with the contents of other_hash.
用指定参数的other_than 替换hash的内容。
h = { "a" => 100, "b" => 200 }
h.replace({ "c" => 300, "d" => 400 }) #=> {"c"=>300, "d"=>400}
select {|key, value| block} → a_hash
select → an_enumerator
返回满足block条件的条目组成的新hash。
如果没有block, 返回一个枚举器。
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}
select! {| key, value | block } → hsh or nil
select! → an_enumerator
等同于 #keep_if, 不过返回nil如贵哦没有改变。
shift → anArray or obj
将开头的键值对从hash中删除，并以[key,value]数组形式返回， 或者返回缺省值如果hash是空的。
h = { 1 => "a", 2 => "b", 3 => "c" }
h.shift #=> [1, "a"]
h #=> {2=>"b", 3=>"c"}
size → integer
返回hash键值对个数。
h = { "d" => 100, "a" => 200, "v" => 300, "e" => 400 }
h.size #=> 4
h.delete("a") #=> 200
h.size #=> 3
h.length #=> 3
slice(*keys) → a_hash
Returns a hash containing only the given keys and their values.
h = { a: 100, b: 200, c: 300 }
h.slice(:a) #=> {:a=>100}
h.slice(:b, :c, :d) #=> {:b=>200, :c=>300}
store(key, value) → value
将给定的key,value以键值对形式存储到hash .
h = { "a" => 100, "b" => 200 }
h["a"] = 9
h["c"] = 4
h #=> {"a"=>9, "b"=>200, "c"=>4}
h.store("d", 42) #=> 42
h #=> {"a"=>9, "b"=>200, "c"=>4, "d"=>42}
to_a → array
将hash 转换为 嵌套数组 [[ key, value ],...]
h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300 }
h.to_a #=> [["c", 300], ["a", 100], ["d", 400]]
to_h → hsh or new_hash
to_h {|key, value| block } → new_hash
返回 self. 如果调用hash的子类，将接收者转换成Hash 对象。
如果指定block，则接收者的每一对的block结果将被被用作相应的对。
to_hash => hsh
返回 self.
to_proc → proc
返回将键值映射的Proc。
h = {a:1, b:2}
hp = h.to_proc
hp.call(:a) #=> 1
hp.call(:b) #=> 2
hp.call(:c) #=> nil
[:a, :b, :c].map(&h) #=> [1, 2, nil]
to_s()
inspect的别名。
transform_keys {|key| block } → new_hash
transform_keys → an_enumerator
将key 用block变换。本方法不改变值value.
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 }
如果没有block, 返回一个枚举器。
transform_keys! {|key| block } → hsh
transform_keys! → an_enumerator
将key 用block变换,替换原来的key,返回hash。本方法不改变值value.
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 }
如果没有指定block,则返回迭代器。
transform_values {|value| block } → new_hash
transform_values → an_enumerator
用block的新值更新hash中的value.然后返回hash.
本方法不改变keys。
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" }
如果没有指定block,则返回迭代器。
transform_values! {|value| block } → hsh
transform_values! → an_enumerator
用block的新值更新hash中的value.然后返回hash.
本方法不改变keys。
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" }
如果没有指定block,则返回迭代器。
update(other_hash1, other_hash2, ...) → hsh
update(other_hash1, other_hash2, ...) {|key, oldval, newval| block}
给定hash内容更新给接收者
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}
value?(value) → true or false
检查hash是否包含参数value. 返回 true/false.
h = { "a" => 100, "b" => 200 }
h.value?(100) #=> true
h.value?(999) #=> false
values → array
返回含有hash中values 的数组。
h = { "a" => 100, "b" => 200, "c" => 300 }
h.values #=> [100, 200, 300]
values_at(key, ...) → array
返回keys对应values 的数组。
h = { "cat" => "feline", "dog" => "canine", "cow" => "bovine" }
h.values_at("cow", "cat") #=> ["bovine", "feline"]