ruby base之类型

1 Array
Array也称作数组，是一系列元素的有序集合。你可以显式使用Array类的new方法来创建一个数组对象，你也可以用方括号包围起来一些以逗号分隔的数字或字符串构成一个数组。

数组可以使用 [] 来索引，其实 [] 是Array类的一个方法，它甚至可以被子类覆盖(overridden)。Ruby中比较有趣的是有多种对数组的索引方法，你可以用负数来索引数组。负数表示从尾部开始，例如索引为-1表示最后一个元素，索引为-2表示倒数第二个元素，以此类推。

你也可以使用一对数来索引数组，第一个数表示开始位置，第二数表示从开始位置起的元素数目。

你甚至可以用一个范围来索引数组，.. 表示包含尾部元素，... 表示不包含尾部元素。

slice方法很简单就像是[ ]方法的别名：

x = [0, 2, 4, 6, 8, 10, 12]
a = x.slice(2) # 4
b = x.slice(2,4) # [4, 6, 8, 10]
c = x.slice(2..4) # [4, 6, 8]

方法first与last分别返回数组的第一个和最后一个元素。如果数组为空，它们将返回nil。这儿是一个例子：(译注：它们也可接受一个参数，用于指出从第一个开始返回几个值。)

a = [ "q", "r", "s", "t" ]
a.first #=> "q"
a.first(1) #=> ["q"]
a.first(3) #=> ["q", "r", "s"]

array = ["Bear", "Benford", "Egan"]
p array.map{|name| "G. #{name}" }
# "G.Bear"
# "G.Benford"
# "G.Egan"
array = ["73", "2", "5", "1999", "53"]
# デフォルトの文字列ソート(辞書式)
p array.sort                            #=> ["1999", "2", "5", "53", "73"]
# 数値に変換してから比較してソート
p array.sort{|x, y| x.to_i <=> y.to_i}  #=> ["2", "5", "53", "73", "1999"]
array.each_with_index do |item,index|
p [item,index]
end
#["2",0]
#["5",1]
#["53",2]
#["73",3]
#["1999",4]

2 Hash
to_a 之后为二维数组

3 Number
和C/C++相同，Ruby规定以0开头的数为八进制数，以0x开头的数为十六进制数，以0b开头的数为二进制数。

irb(main):001:0> 16
=> 16
irb(main):002:0> 020#8进制
=> 16
irb(main):003:0> 0x10#16进制
=> 16
irb(main):004:0> 0b10000#二进制
=> 16

一个数中间可以用下划线连接，下划线自动被忽略。

irb(main):005:0> 123_456_789
=> 123456789

4 String
String也称作字符串，是单引号或双引号包围起来的一串字符。单引号和双引号的意义有所不同，双引号包围的字符作变量替换，单引号包围的变量不做替换。可以在字符串中使用 #{expr} 嵌入代码#估计一般就嵌入简单的表达式吧。

也可以使用 %q 和 %Q 来生成字符串对象。%q 相当于单引号，%Q相当于双引号。紧跟在q或Q之后的第一个字符是该字符串的分界符，从该分界符之后的第一个字符开始知道下一个相匹配（未被转义）的分界符之间的内容就组成了该字符串。如果起始分界符为(、[、{、那么与之相匹配的分界符就是)、]、}或>,否则结束分界符就是和起始分界符同样的字符。

%q 和 %Q 后面的第一个字符为分隔符。二个分隔符之间的字符被认为一个是字符串。但是如果这个分隔符是 [ { <, 那么结束标志为匹配的 ] } >。

你也可以使用“Here Document”的方法来生成字符串，这种方法规定 << 之后的字符串作为结束标志。

string = <<END_OF_STRING
With publication started in June 1948 and a current circulation of 3 million,
People's Daily is the most influential and authoritative newspaper in China.
According to UNESCO, it takes its place among the world top 10.
END_OF_STRING

5 Range
Range也称作范围，用来表示一个都是连续的值的序列。可以使用 .. 和 ... 操作符来产生Range，..表示包含最后一个元素，...表示不包含最后一个元素。Range对象所属的类是Range。注意Range和
Array是不同的，可以使用Range类的to_a方法将一个Range对象转化为Array对象。

irb(main):003:0> (1..10).to_a
=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
irb(main):004:0> ('bar'..'bat').to_a
=> ["bar", "bas", "bat"]
irb(main):005:0> (1...10).to_a
=> [1, 2, 3, 4, 5, 6, 7, 8, 9]

Range除了表示一个序列外还可以出现在条件语句中。在条件语句中，可以把Range看作一个双向开关，当第一个条件满足时打开开关，当第二个条件满足时关闭开关。

a = [0, 1, 2, 3, 4, 5, 6]
a.each do |i|
  print i, " " if i == 1 .. i == 5
end
1 2 3 4 5 => [0, 1, 2, 3, 4, 5, 6]

irb(main):026:0> a.each do |i|

irb(main):027:1*   puts i, " " if i == 1 .. i == 5

irb(main):028:1> end

1
2
3
4
5

可以使用 === 来测试一个元素是否在某个范围：

irb(main):093:0> (1..10) === 3
=> true
irb(main):094:0> (1..10) === 30
=> false
irb(main):095:0> (1..10) === 2.71828
=> true
irb(main):096:0> ('a'..'f') == 'c'
=> false
irb(main):097:0> ('a'..'f') == 'g'
=> false

Range也可以位于case语句之内：

score = 98
case score
when 85..100 then puts "A"
when 70...85 then puts "B"
when 60...70 then puts "C"
else puts "D"
end
执行结果为：
A

6 Symbol
Symbol是个简单的对象，它使用名字作为唯一的标识符。Symbol对象代表解释器内部一个唯一的名字。Symbol的产生:只需要给一个字符序列前添加“：”或使用“to_sym”方法。 Symbol对象从属于Symbol类。
String和Symbol两者具有紧密的联系。每个symbol都有个字符串的名字(可以使用to_s方法得到)。而每个String可以请求它的相应symbol(通过to_sym方法)。String和Symbol是紧密相联的，但它们不是同一个东西，他们分别是String类和Symbol类的对象。
因为symbol可以大大提高速度。Symbol的内部表示是一个整数，用来做Hash表中检索字符串的关键字，而Ruby语言执行时解析器、运算器需要大量的类名字、方法名字的检索，这可以大大加快解析和执行时字符串查找的速度。
想想，如果没有Symbol，如果需要用方法名称作为参数时，我们必须给一个字符串用来表示方法的名称，解释器处理时首先要作字符串解析，然后才能找到出相应的方法，而如果使用Symbol会大大加快这一速度。
在使用中，Symbol往往表示一个名字，例如一个变量 foo的值为1，那么 :foo可以理解为变量名，如果直接引用foo，会得到1，但如果是 :foo就指变量名本身。
Symbol对象是唯一的。每次你在代码中使用:test, 你是要引用一个名字为"test"的Symbol类的对象。Ruby保证系统中只有一个名字为test的Symbol对象, 所以所有对:test的引用都将引用同一个对象。

module One
  class Test
  end
  $f1 = :Test
end
=> :Test
module Two
  Test = 1
  $f2 = :Test
end
=> :Test
def Test()
end
=> nil
$f3 = :Test()
=> :Test
$f1.object_id
=> 4
$f2.object_id
=> 4
$f3.object_id
=> 4

[如果你用大写字母开头定义一个方法，你不会立即得到一个错误，但是当你调用这个方法时，Ruby首先认为你访问的是一个常量，所以可能会解析错误]
=结尾：赋值方法，相当于其他编程语言的set开头的方法，算是一种语法蜜糖。
!结尾：破坏性方法，调用这个方法会修改本来的对象，这种方法通常有个非破坏性的版本，调用非破坏性的版本会回传一个对象的副本。
?结尾：表示这个函数的回传值是个布林值。
7 正则表达式
正则表达式的类是Regexp，可以使用/或%r生成正则表达式。

irb(main):103:0> a = /\s*[a-f]/
=> /\s*[a-f]/
irb(main):104:0> a.class
=> Regexp
irb(main):105:0> b = %r{\s*[a-f]}
=> /\s*[a-f]/
irb(main):106:0> b.class
=> Regexp
irb(main):107:0> c = Regexp.new('\s*[a-f]')
=> /\s*[a-f]/
irb(main):108:0> c.class
=> Regexp

你可以使用Regexp#match(string)方法或者=~运算符来匹配正则表达式，你也可以使用!~来测试是否不匹配。

irb(main):113:0> sentence = "This is a dog."
=> "This is a dog."
irb(main):114:0> sentence =~ /dog/
=> 10
irb(main):115:0> sentence =~ /a/
=> 8
irb(main):116:0> /a/ =~ sentence
=> 8
irb(main):117:0> sentence !~ /xyz/
=> true

另外，在匹配正则表达式时，会将匹配到的字符串存放在 $& 变量中，$`变量中存放已经匹配过的字符序列，$'变量中存放还未匹配的字符序列。#教材上明显错误哈

irb(main):118:0> sentence = "This is a dog."
=> "This is a dog."
irb(main):119:0> sentence =~ /a/
=> 8
irb(main):120:0> puts $&
a
=> nil
irb(main):121:0> puts $'
dog.
=> nil
irb(main):122:0> puts $`
This is
=> nil