持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的第8天，点击查看活动详情
二、Hash 对象的相关操作
Ruby 中提供了两种容器对象既数组和 Hash 对象。数组和 Hash 对象可以认为是同一对象的两种不同的表现形式，数组可以看做是一种特殊形式的 Hash 对象，Hash 对象里的 Key 是任意元素，而数组中的 Key 是连续的整数既索引，并且从零开始。通常情况下称 Hash 对象为关联数组对象或者字典对象。
Hash 对象在元素由两部分组成，Key 和 Value，使用 => 隔开，多个 Key Value 之间使用逗号分隔
student = {
"name" => "Tom",
"age" => 25,
"sex" => "男"
}
puts student
执行上述代码，输出结果如下：
{"name"=>"Tom", "age"=>25, "sex"=>"男"}
在 Hash 对象中，如果为同一个 Key 指定了两个 Value，那么后面指定的 Value 将会覆盖前面指定的 Value。
除了可以通过 {k=>v} 的方式来创建 Hash 对象，还可以使用 Hash 类实例化的方式来创建，创建之后可以动态的添加元素。
stu = Hash.new
stu["name"] = "Peter"
stu["age"] = 24
stu["sex"] = "女"
puts stu
执行上述代码，输出结果如下：
{"name"=>"Peter", "age"=>24, "sex"=>"女"}
Hash 对象常用的方法
stu = Hash.new
stu["name"] = "Peter"
stu["age"] = 24
stu["sex"] = "女"
puts stu
# Hash 对象相关的方法
puts stu.to_s
puts stu.size
puts stu.length
puts stu.has_key?("name")
puts stu.delete("name")
puts stu.keys
puts stu.values
puts stu
执行上述代码，输出结果如下：
{"name"=>"Peter", "age"=>24, "sex"=>"女"}
{"name"=>"Peter", "age"=>24, "sex"=>"女"}
3
3
true
Peter
age
sex
24
女
{"age"=>24, "sex"=>"女"}
在对 Hash 对象进行遍历时，可以使用 Hash 对象的迭代器进行遍历。
stu = Hash.new
stu["name"] = "Peter"
stu["age"] = 24
stu["sex"] = "女"
# 迭代
puts "迭代 Hash 对象"
puts "迭代 Hash 对象中的全部元素，key 和 value"
stu.each do |item|
puts item
end
puts "迭代 Hash 对象中的所有的 Key"
stu.each_key do |k|
puts k
end
puts "迭代 Hash 对象中的全部 Value"
stu.each_value do |v|
puts v
end
puts "迭代 Hash 对象中的 key=>value 对"
stu.each_pair do |k,v|
puts k.to_s + "=>" + v.to_s
end
执行上述代码，输出结果如下：
迭代 Hash 对象中的全部元素，key 和 value
name
Peter
age
24
sex
女
迭代 Hash 对象中的所有的 Key
name
age
sex
迭代 Hash 对象中的全部 Value
Peter
24
女
迭代 Hash 对象中的 key=>value 对
name=>Peter
age=>24
sex=>女
三、Array 对象的相关操作
数组是一组存储数据对象的集合，可以通过索引来访问数组中的元素。Ruby 中定义数组可以使用 [] 并使用 , 将多个元素隔开即可。
names = ["peter", "will", "dusting"]
puts names
执行上述代码，输出结果如下：
peter
will
dusting
数组还可以通过实例化 Array 类的方式来创建，通过索引添加元素。
names = Array.new
names[0] = "peter"
names[1] = "will"
names[2] = "dusting"
puts names
puts names[2]
puts names.size
puts names[5]
puts names[1,3]
执行上述代码，输出结果如下：
peter
will
dusting
dusting
3
will
dusting
数组对象可以通过索引添加元素，也可以通过索引访问元素或者进行切片操作，数组可以通过调用 size 或者 length 方法来获取数组的长度，如果索引超过了数组长度，则访问到的元素为空。
% 表示法
Ruby 中可以将一个包含多个空格的字符串转换为一个数组，Ruby会将空格作为数组元素的分隔符，每个被空格分隔的字符串都会被当成一个数组元素。如果希望将多个包含空格的字符串转换维数组，则需要使用 %w{...} 或者 %W{...} 表示法，使用 %W{...} 表示法会对字符串中的转义字符和特殊字符进行替换。
str = %W{Hello\sRuby\s!}
puts str
str = %w{Hello\sRuby\s!}
puts str
执行上述代码，输出结果如下：
Hello Ruby !
Hello\sRuby\s!
添加和删除数组元素
Array 对象可以通过调用方法对对象中的元素进行添加和删除操作，方法如下：
| 方法 | 说明 |
|---|---|
| unshift | 向数组的头部添加元素 |
| push | 向数组的尾部添加元素 |
| << | 向数组的尾部添加一个数组元素 |
| shift | 删除数组头部元素，并返回 |
| pop | 删除数组尾部元素，并返回 |
names = Array.new
names[0] = "peter"
names[1] = "will"
names[2] = "dusting"
puts "names 数组头部添加元素后"
names.unshift("el", "eleven")
puts names
puts "names 数组尾部添加元素后"
names.push("steven", "robin")
puts names
puts "names 数组为部添加一个元素后"
names << ("stark")
puts names
puts "names 数组删除头部元素"
name = names.shift
puts name
puts "names 数组删除尾部元素"
name = names.pop
puts name
执行上述代码，输出结果如下：
names 数组头部添加元素后
el
eleven
peter
will
dusting
names 数组尾部添加元素后
el
eleven
peter
will
dusting
steven
robin
names 数组为部添加一个元素后
el
eleven
peter
will
dusting
steven
robin
stark
names 数组删除头部元素
el
names 数组删除尾部元素
stark
截取和合并数组
数组也支持切片操作，可以通过向 array[] 传递两个参数来截取数组，方法如下：
| 方法 | 说明 |
|---|---|
| array[n, m] | 截取从索引 n 开始，长度为 m 的元素列表，返回一个新的数组 |
| array[n..m] | 截取从索引 n 开始，到索引 m 的元素列表(包含索引为 m 的元素)，返回一个新数组 |
| array[n...m] | 截取从索引 n 开始，长度为 m 的元素列表(不包含索引为 m 的元素)，返回一个新数组 |
还可以通过调用数组的 concat 方法来合并两个数组对象。
names = Array.new
names[0] = "peter"
names[1] = "will"
names[2] = "dusting"
names[3] = "el"
names[4] = "steve"
names[5] = "robin"
puts "截取从索引 0 开始长度为 3 的元素列表"
_names = names[0, 3]
puts _names
puts _names.class
puts "截取从索引 0 开始到索引 3 的元素列表，包含索引 3 位置的元素"
_names = names[0..3]
puts _names
puts _names.class
puts "截取从索引 0 开始到索引 3 的元素列表，不包含索引 3 位置的元素"
_names = names[0...3]
puts _names
puts _names.class
执行上述代码，输出结果如下：
截取从索引 0 开始长度为 3 的元素列表
peter
will
dusting
Array
截取从索引 0 开始到索引 3 的元素列表，包含索引 3 位置的元素
peter
will
dusting
el
Array
截取从索引 0 开始到索引 3 的元素列表，不包含索引 3 位置的元素
peter
will
dusting
Array
数组的合并操作
names = Array.new
names[0] = "peter"
names[1] = "will"
names[2] = "dusting"
puts "合并数组"
names_02 = ["stark", "thor"]
puts "合并前 names 数组的内存地址"
puts names.__id__
puts names.concat(names_02)
puts "合并后的数组为"
puts names
puts "合并后 names 数组的内存地址"
puts names.__id__
执行上述代码，输出结果如下：
合并数组
合并前 names 数组的内存地址
70215119445880
peter
will
dusting
stark
thor
合并后的数组为
peter
will
dusting
stark
thor
合并后 names 数组的内存地址
70215119445880
通过 concat 方法合并数组是在原来数组上做修改，不会生成新的数组。可以通过 id 方法查看对象的内存地址。
四、类型转换
类型转换就是将把一种数据类型转换为另一种数据类型，如数字类型可以通过 to_s 方法转变为字符串类型，除了 to_s 之外还有其他内置的类型转换方法：
- to_i：将对象转换成整数类型
- to_f：将对象转换成浮点数类型
除此之外，还可以自定义类型转换方法 to_*。
class Computer # 定义一个 Computer 类
def initialize(brand) # 定义构造函数
@brand = brand
end
def to_s # 定义 to_s 方法
"电脑品牌是：#{@brand}"
end
end
computer = Computer.new("Mac") # 实例化 Computer 类
puts computer.to_s
执行上述代码，输出结果如下：
电脑品牌是：Mac
