Ruby中的数字就是一系列的对象，你可以通过
位置或者说
索引来访问数组中的元素。在Ruby中数组的第一个元素的索引是0，数组的长度是数组中元素的个数，Ruby数组允许负数索引，最后一个元素的索引是-1，倒数第二个的索引是-2，一次类推，如果你试图使用一个超出范围的索引方法数组你会得到一个nil值，而不会出现异常。
Ruby的数组是可变的，而且无类型的，也就是说你可以在任何时候改变数组内的元素，数组内的元素与不必全部是相同的类型。另外，数字的长度是动态可变的，如果你向其中增加一个元素，数组的长度就会自动扩展，如果你用一个越界索引给数组赋值，它会用一个nil值来扩展数组。
声明一个数组要使用[]，其中的元素用逗号分隔:
[1, 2, 3] # 一个包含3个Fixnum对象的数组。
[-10...0, 0..10,] # 这个数组包含两个Range对象，结尾的逗号是允许的。
[[1,2],[3,4],[5]] # 包含数组的数组
[x+y, x-y, x*y] # 数组元素还可以是表达式
[] # 空数组的长度为0
用%w方式你可以把用分割符号包含的；用空格隔开的不同字符串定义为一个数组：
words = %w[this is a test] # 等同于: ['this', 'is', 'a', 'test']
open = %w| ( [ { < | # 等同于: ['(', '[', '{', '<']
white = %W(\s \t \r \n) # 等同于: ["\s", "\t", "\r", "\n"]
用%w或%W定义数组的方式类似于用%q和%Q定义字符串，分界符号的规则也一样，在分界符号中的元素无需分号(''，“”)包含，无需逗号分隔，不同元素之间用空格隔开。
你还可以通过Array.new 来定义数组，这种方式可以让你通过程序化的手段还初始化数组:
empty = Array.new # []: 创建一个空的数组
nils = Array.new(3) # [nil, nil, nil]: 包含3个nil的数组
zeros = Array.new(4, 0) # [0, 0, 0, 0]: 创建包含4个0的数组
copy = Array.new(nils) # 创建另一个数组对象的拷贝
count = Array.new(3) {|i| i+1} # [1,2,3]: 通过计算得到的数组，你可以在数组声明后加上一个块，来填充数组
可以通过[一个整数索引] 的方式获得数组元素的值。
a = [0, 1, 4, 9, 16] # 创建一个数组
a[0] # 第一个元素是 0
a[-1] # 最后一个元素是 16
a[-2] # 倒数第二个元素是 9
a[a.size-1] # 另一种获得最后一个元素的方法
a[-a.size] # 另一种获得第一个元素的方法
a[8] # 越界访问会得到一个 nil值
a[-8] # 越界访问会得到一个 nil值
可以通过赋值的方法修改数字内的元素：
a[0] = "zero" # a 变成 ["zero", 1, 4, 9, 16]
a[-1] = 1..16 # a 变成 ["zero", 1, 4, 9, 1..16]
a[8] = 64 # a 变成 ["zero", 1, 4, 9, 1..16, nil, nil, nil, 64]，增加了新的元素。
a[-9] = 81 # 这里会抛出异常，你不能向数组第一个元素之前赋值。
和String对象的操作一样，你同样可以使用两个整数下标或者一个Range对象下标的方式获得一个子数组：
a = ('a'..'e').to_a # to_a方法将一个Range对象转换为数组 ['a', 'b', 'c', 'd', 'e']
a[0,0] # []: 得到一个空的数组
a[1,1] # ['b']: 得到包含一个元素的数组
a[-2,2] # ['d','e']: 得到包含最后两个元素的数组
a[0..2] # ['a', 'b', 'c']: 包含前面3个元素的数组
a[-2..-1] # ['d','e']: 通过Range的方式获得最后两个元素
a[0...-1] # ['a', 'b', 'c', 'd']: 除最后一个元素外所以元素的数组
可以通过赋值的操作将数组中的子数组修改成其他的内容：
a[0,2] = ['A', 'B'] # a 变成了 ['A', 'B', 'c', 'd', 'e']
a[2...5]=['C', 'D', 'E'] # a 变成了['A', 'B', 'C', 'D', 'E']
a[0,0] = [1,2,3] # 在数组 a之前增加3个元素
a[0..2] = [] # 删除这些元素
a[-1,1] = ['Z'] # 用一个新值替换最后一个元素
a[-1,1] = 'Z' # 如果只修改一个元素，赋值的对象不必一定是数组
a[-2,2] = nil # 在Ruby 1.8中会删除最后两个元素; 在Ruby 1.9中会将最后两个元素替换为nil对象。
你还可以用+符号链接两个数组：
a = [1, 2, 3] + [4, 5] # [1, 2, 3, 4, 5]
a = a + [[6, 7, 8]] # [1, 2, 3, 4, 5, [6, 7, 8]]
a = a + 9 # 这里会抛出异常，因为只有都是数组的情况下才可以“相加”
你还可以使用-符号来从数组中移除指定的元素:
a=['a', 'b', 'c', 'd', 'e']
b=['b', 'c', 'b']
c=a-b
puts "a:#{a},b:#{b},c:#{c}"
输出结果是：
a:["a", "b", "c", "d", "e"],b:["b", "c", "b"],c:["a", "d", "e"]
包含在b中的元素被从a中移除了，但是这个操作不会改变数组a和b本身，只是返回计算结果的拷贝。
我们前面提到的+操作创建了一个链接后的新的数组但是不改变数组本身，而<<会向数组中追加元素，数组本身的内容也发生了改变
a = [] #创建空的数组
a << 1 # a 变成 [1]
a << 2 << 3 # a 变成 [1, 2, 3]
a << [4,5,6] # a 变成 [1, 2, 3, [4, 5, 6]]
和String一样数组也提供了乘法操作：
a = [0] * 8 # [0, 0, 0, 0, 0, 0, 0, 0]
数组对象还引入了
布尔操作符:|和&,用他们来取两个数组的交集和并集。|操作将两个数组的重复元素移除并返回两个数组的并集，&操作返回两个数组的交集。
a = [1, 1, 2, 2, 3, 3, 4]
b = [5, 5, 4, 4, 3, 3, 2]
a | b # [1, 2, 3, 4, 5]: 重复元素被移除
b | a # [5, 4, 3, 2, 1]: 元素内容相同，但是顺序变了
a & b # [2, 3, 4]
b & a # [4, 3, 2]
Ruby为数组定义了一系列非常有用的方法，我们这里只介绍一下each方法：
a = ('A'..'Z').to_a # 创建一个数组
a.each {|x| print x } # 迭代打印出数组中的每个元素
还有很多其他有用的方法诸如：
clear,
compact!,
delete_if,
each_index,
empty?,
fill,
flatten!,
include?,
index,
join,
pop,
push,
reverse,
reverse_each,
rindex,
shift,
sort,
sort!,
uniq!, 和
unshift.，我们将在以后的章节进行介绍。
