数组类。数组的元素可以是任何 Ruby 对象。详细参看 数组表达式 。
超类Object（物件） 包含的模块Enumerable 可举列模块 方法self[nth]
获取第 nth 个数组元素。索引从 0 开始。若 nth 为负值，则从尾部开始算起（最后一个元素的索引为 -1）。若第 nth 个元素不存在，则返回 nil。
self[start, length]
返回从 start 算起，包含 length 个元素的数组。若 start 为负值，则从尾部开始算起（最后一个元素的索引为 -1）。若 length 超出从 start 算起的数组剩余长度，则忽略超出的部分。若 length 为负值则返回 nil。
self[nth]=val
将数组的第 nth 个元素之值改为 val。若 nth 超出数组范围，则数组会自动延伸。所延伸的部分初始化为 nil。
返回?val。
self[start, length]=val
将数组中从 start 开始算起 length 个元素的内容替换成 val 。若 val 非数组，则调用 val.to_ary 或使用 [val] 来进行替换。返回 val 。
ary = [0, 1, 2, 3]ary[1, 2] = ["a", "b", "c"]p ary ? ? ? ? ? ? ? ? # => [0, "a", "b", "c", 3]ary[2, 1] = 99p ary ? ? ? ? ? ? ? ? # => [0, "a", 99, "c", 3]ary[1, 0] = ["插入的文字"]p ary ? ? ? ? ? ? ? ? # => [0, "插入的文字", "a", 99, "c", 3]
self + other
将 self 和 other 的内容连结起来并返回一个新的数组。若 other 不是数组，则使用 other.to_ary 的返回值。若返回值不是数组，抛出 TypeError(异常：类型错误) 异常。
a = [1, 2]b = [8, 9]p a + b ? ? ? ? ? ? ? # => [1, 2, 8, 9]p a ? ? ? ? ? ? ? ? ? # => [1, 2] (不变)p b ? ? ? ? ? ? ? ? ? # => [8, 9] (同样不变)
self – other
减集操作。返回一个包含所有 self 元素、但是减去所有 other 元素的新数组。
self & other
交集操作。返回一个包含在 self 和 other 共有元素的数组。移除重复的元素。
self | other
并集操作。返回一个包含在 self 和 other 所有元素的数组。移除重复的元素。
self <=> other
使用 <=>依次比较 self 和 other 的元素，若 self 大于 other，则返回 1、若 self 等于 other，则返回 0、若 self 小于 other，则返回 -1。若是各元素均相等，且其中一个数组已到达尾部时，较短的数组判定为小。
self == other
使用 == 依次比较各个元素，若所有元素都相等则返回 true。
clear
将数组清空，删除所有元素。返回 self。
ary = [1, 2]ary.clearp ary ? ? ? ? ? ? ? ? # => []
clone dup
返回一个与调用者有同样内容的数组。clone?完完全全复制一个数组、包括冻结状态、特殊方法等，而 dup 只有复制对象内容而已。clone 和 dup 都不会复制方法或元素本身。
compact!
返回一个除了 nil 元素以外，包含所有 self 元素的数组。compact! 则是执行破坏性更新，若成功修改，就返回 self，否则返回 nil。
ary = [1, nil, 2, nil, 3, nil]p ary.compact ? ? ? ? # => [1, 2, 3]p ary ? ? ? ? ? ? ? ? # => [1, nil, 2, nil, 3, nil]ary.compact!p ary ? ? ? ? ? ? ? ? # => [1, 2, 3]p ary.compact! ? ? ? ?# => nil
concat(other)
将 other 连结到 self（破坏性操作）。返回 self。
array = [1, 2]a = [3, 4]array.concat ap array ? ? ? ? ? ? ? # => [1, 2, 3, 4]p a ? ? ? ? ? ? ? ? ? # => [3, 4] # 没有变化
delete(val) delete(val) { … }
删除所有等于 val （借由 ==）的元素。若有任何元素与 val 相等，返回 val。
若没有任何元素与 val 相等，返回 nil。若指定了区块，则对区块进行计算并返回计算结果。
array = [1, 2, 3, 2, 1]p array.delete(2) ? ? # => 2p array ? ? ? ? ? ? ? # => [1, 3, 1]# 若参数为 nil 而没有指定区块，则无法从返回值判断到底有没有进行删除ary = [nil,nil,nil]p ary.delete(nil) ? ? # => nilp ary ? ? ? ? ? ? ? ? # => []p ary.delete(nil) ? ? # => nil
delete_at(pos)
删除在 pos 位置的元素，并返回被删除的元素。若 pos 超出数组范围则返回 nil。
array = [0, 1, 2, 3, 4]array.delete_at 2p array ? ? ? ? ? ? ? # => [0, 1, 3, 4]
each {|item| …. }
依次使用各个元素来对区块进行计算。返回 self。
# 依次显示 1、2、3[1, 2, 3].each do |i| puts iend
each_index {|index| …. }
依每个元素的索引，对区块进行计算。与下面的语句相同：
(0 ... ary.size).each {|index| .... }
返回?self。
empty?
若元素数为 0，返回 true。
include?(val)
若数组中任一元素等于 val（使用==），返回 true。
index(val)
返回数组第一个等于 val（使用 ==）的元素的索引。若找不到相等的元素则返回 nil。
insert(nth, [val[, val2 …]])
在第 nth 个元素前面插入第二个参数以及后面的所有参数。返回 self。定义如下：
class Array ?def insert( n, *vals ) ?? self[n, 0] = vals ?? self ?endend
ary = ["foo", "bar", "baz"]ary.insert 2, 'a', 'b'p ary ? ? ? ? ? ? ? ?? # => ["foo", "bar", "a", "b", "baz"]
若没有指定 val 的参数，则什么都不做。
length size
返回数组的长度。若数组为空，返回 0。
nitems
返回非 nil 的元素数目。
pop
删除并返回最后一个元素。若数组为空，返回 nil。
array = [1, [2, 3], 4]p array.pop ? ? ? ? ?? # => 4p array.pop ? ? ? ? ? ?# => [2, 3]p array ? ? ? ? ? ? ?? # => [1]p array.pop ? ? ? ? ? ?# => 1p array.pop ? ? ? ? ? ?# => nilp array ? ? ? ? ? ? ? ?# => []
push(obj1[, obj2 …])
依次将 obj1, obj2 … 插入数组的尾部。
返回?self。
array = [1, 2, 3]array.push 4array.push [5, 6]array.push 7, 8p array ? ? ? ? ? ? ? ?# => [1, 2, 3, 4, [5, 6], 7, 8]
reverse reverse!
reverse 返回一个与原数组元素顺序相反的辛数组。reverse! 则是执行破坏性更新。
reverse 总是返回一个新的数组，而 reverse! 返回 self。
shift
删除并返回第一个元素。剩余的元素会自动向前补足空缺。若数组为空，则返回 nil。
sort sort! sort {|a, b| … } sort! {|a, b| … }
将数组内容排序。若是带区块调用，则传递两个参数给区块，用区块计算的结果进行排序。不带区块时，使用 <=> 对元素进行比较。sort! 则是对数组元素进行破坏型更新。
sort 返回一个新的、并进行过排序的数组，而 sort! 必定返回 self。
uniq uniq!
uniq 返回一个移除重复元素的新数组。剩余的元素会自动向前补足空缺。uniq! 近行破坏性删除，成功执行删除时返回 self ，否则返回 nil。
unshift(obj1[, obj2 …])
将 obj1、obj2 … 依次插入在数组的头部。
返回?self。
别想一下造出大海，必须先由小河川开始。
