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