ruby基础之数组（array）类
数组类
建立数组([]、使用Array.new、使用%w)
e.g. num = [1, 2, 3, 4]
strs = ["a", "b", "c", "d"]
a = Array.new p a #=>[]
a = Array.new(5) p a #=>[nil, nil, nil, nil, nil]
a = Array.new(5, 0) p a #=>[0, 0, 0, 0, 0]
lang = %w(ruby perl python scheme pike rebol) p lang #=>["ruby", "perl", "python", "scheme", "pick", "rebol"]
转化成数组（使用to_a方法、使用字符串split方法）
e.g. color_table = {"black" => "#000000", "white" => "#ffffff"} p color_table.to_a #=>[["black", "#000000"], ["white", "#ffffff"]]
column = "a,b,c,d" p column.split(/,/) #=>["a", "b", "c", "d"]
获取元素（a[n]、 a[n..m]或a[n...m]、 a[n, len]）
a[n] // 这个不多介绍，负值的情况要注意一下，e.g. alpha = ["a", "b", "c", "d"] p alpha[-1] #=> "d"
a[n..m] // 将数组的元素“a[n]” 至“a[m]” 之间的范围建立新的数组并返回
a[n...m] // 将数组元素“a[n]” 至 “a[m-1]” 之间的元素建立新的数组并返回
a[n, len] // 从“a[n]”处开始获取len个元素，建立新的数组并返回
除了"[]"这个方法外，还有其他的：
a.at(n) // 等同于a[n]
a.slice(n) // 等同于a[n]
a.slice(n..m) // 等同于a[n..m]
a.slice(n, len) // 等同于a[n, len]
注意：slice 和 slice! 作用是不一样的，slice！会删除掉指定的元素，而slice是获取指定元素
改写元素（[]、 at、 slice）
这些方法，不但能读取元素，还可以用来写入数组的元素
e.g. a[n] = "item"
其他的不多举例了，自己去看一下，这个比较简单
插入元素（a[n,0]）
a[n, 0] // 在索引n处，换掉0个元素，实际上就是在索引n处插入元素， e.g. alpha = ["a", "b", "c", "d", "e"] alpha[2, 0] = ["X", "Y"] p alpha #=> ["a", "b", "X", "Y", "c", "d", "e"]
以多个索引建立新数组(values_at)
values_at // 指定多个索引，跳着取值，返回新数组。e.g. alpha = %w(a b c d e f) p alpha.values_at(1, 3, 5) #=>["b", "d", "f"]
作为集合的数组
集合的运算是：交集（array = array1 & array2）、 并集（array = array1 | array2）、 补集（由于Array类没有‘全集’的概念，故，没有‘补集’，但是，将一个集合减去另一个集合，做‘差集’运算）
e.g. ary1 = ["a", "b", "c"] ary2 = ["b", "c", "d"]
p (ary1 & ary2) #=>["b", "c"]
p (ary1 | ary2) #=>["a", "b", "c", "d"]
p (ary1 - ary2) #=>["a"] // 数组ary2里所包含的元素“d” 因为在ary1里并没有，所以也不会留下。
注意：“|”与“+”的差异，当两个数组具有相同元素的时候，“+”返回的数组会出现相同的元素，而“|”则不会。
作为"列表"的数组
这种情况，常用到的方法有：
对前端操作 对末端操作
加入元素 unshift push
取出元素 shift pop
读取元素 first last
以上方法中，pop和shift方法不仅会获取数组的元素，还会从数组里删除该元素。当不希望元素被删除时，我们应该使用first方法和last方法，这两个方法只是读取数据而已
e.g. a = [1, 2, 3, 4, 5]
p a.first #=> 1
p a.last #=> 5
p a #=> [1, 2, 3, 4, 5]
数组的主要方法
a.unshift(item) // 在数组a前方加入新的元素item
a << item 或者 a.push(item) // <<和push是相同的方法，可以在数组a后方加入新的元素item
a.concat(b) 或者 a + b // 将数组a与数组b连接起来。但是concat是破坏性的方法，而“+”则会返回新的数组
破坏性的方法
e.g. a = [1, 2, 3, 4]
b = a
p b.pop #=> 4
p b.pop #=> 3
p b.pop #=> 2
p a #=> 1
p b #=>1
使用pop方法删除数据的时候，变量a所代表的数组元素被删除，由“1， 2， 3， 4”变为“1”，同时变量b所代表的数组元素也被删除。这是因为，在执行“b=a”的时候，并没有将a的内容拷贝给b，而是a和b都共同指向一个对象。
从数组中删除数据
a.compact 与 a.compact! 从数组a中删除nil元素。“compact” 会建立新的数组，而“compact！”会直接改写原来的数组。compact！方法在删除nil以后会返回对象a；但什么都没有删除的时候，会返回nil。
a.delete(x) // 从数组a中删除元素x，返回的是被删除的元素。e.g. a = [1, 2, 3, 2, 1] a.delete(2) p a #=> [1, 3, 1]
a.delete_at(n) // 从数组a中删除索引n处的元素，返回的是被删除的元素。e.g. a = [1, 2, 3, 2, 1] a.delete_at(2) p a #=> [1, 2, 2, 1]
由于时间的关系，还有很多方法没有介绍，大家可以去查找文档，有很多方法的，都很实用。
