Ruby Array类用法及代码示例

数组是有序的 integer-indexed 对象集合，称为 elements 。任何对象都可以是 Array 元素。

数组索引

数组索引从 0 开始，就像在 C 或 Java 中一样。

正索引是从第一个元素的偏移量：

• 索引 0 表示第一个元素。

• 索引 1 表示第二个元素。

• …

负索引是从数组末尾向后的偏移量：

• 索引 -1 表示最后一个元素。

• 索引 -2 表示next-to-last 元素。

• …

如果非负索引小于数组的大小，则为 in range。对于 3 元素数组：

• 索引 0 到 2 在范围内。

• 索引 3 超出范围。

如果其绝对值不大于数组的大小，则负索引为in range。对于 3 元素数组：

• 索引 -1 到 -3 在范围内。

• 索引 -4 超出范围。

创建数组

您可以使用以下命令显式创建 Array 对象：

• 一个 array literal 。

您可以使用以下方法将某些对象转换为数组：

• 方法Array。

一个数组可以包含不同类型的对象。例如，下面的数组包含一个 Integer 、一个 String 和一个浮点数：

ary = [1, "two", 3.0] #=> [1, "two", 3.0]

也可以通过使用零、一( Array 的初始大小)或两个参数(初始大小和默认对象)调用 Array.new 来创建数组。

ary = Array.new    #=> []
Array.new(3)       #=> [nil, nil, nil]
Array.new(3, true) #=> [true, true, true]

请注意，第二个参数使用对同一对象的引用填充数组。因此，仅在需要使用原生不可变对象(例如符号、数字、真或假)实例化数组的情况下才建议使用。

要创建具有单独对象的数组，可以传递一个块。此方法可以安全地用于可变对象，例如哈希、字符串或其他数组：

Array.new(4) {Hash.new}    #=> [{}, {}, {}, {}]
Array.new(4) {|i| i.to_s } #=> ["0", "1", "2", "3"]

这也是构建多维数组的快速方法：

empty_table = Array.new(3) {Array.new(3)}
#=> [[nil, nil, nil], [nil, nil, nil], [nil, nil, nil]]

也可以使用由 Kernel 提供的 Array() 方法创建数组，该方法尝试调用 to_ary ，然后对其参数调用 to_a 。

Array({:a => "a", :b => "b"}) #=> [[:a, "a"], [:b, "b"]]

示例用法

除了通过 Enumerable 模块混合的方法之外， Array 类还具有用于访问、搜索和以其他方式操作数组的专有方法。

一些更常见的如下所示。

访问元素

可以使用 Array#[] 方法检索数组中的元素。它可以采用单个整数参数(数字索引)、一对参数(开始和长度)或范围。负索引从末尾开始计数，-1 是最后一个元素。

arr = [1, 2, 3, 4, 5, 6]
arr[2]    #=> 3
arr[100]  #=> nil
arr[-3]   #=> 4
arr[2, 3] #=> [3, 4, 5]
arr[1..4] #=> [2, 3, 4, 5]
arr[1..-3] #=> [2, 3, 4]

访问特定数组元素的另一种方法是使用 at 方法

arr.at(0) #=> 1

slice 方法的用法方式与 Array#[] 相同。

要为数组边界之外的索引引发错误，或者在发生这种情况时提供默认值，您可以使用 fetch 。

arr = ['a', 'b', 'c', 'd', 'e', 'f']
arr.fetch(100) #=> IndexError: index 100 outside of array bounds: -6...6
arr.fetch(100, "oops") #=> "oops"

特殊方法 first 和 last 将分别返回数组的第一个和最后一个元素。

arr.first #=> 1
arr.last  #=> 6

要返回数组的第一个 n 元素，请使用 take

arr.take(3) #=> [1, 2, 3]

drop 与 take 相反，通过在删除 n 元素之后返回元素：

arr.drop(3) #=> [4, 5, 6]

获取有关 Array 的信息

数组始终跟踪自己的长度。要查询数组包含的元素数量，请使用 length 、 count 或 size 。

browsers = ['Chrome', 'Firefox', 'Safari', 'Opera', 'IE']
browsers.length #=> 5
browsers.count #=> 5

检查数组是否包含任何元素

browsers.empty? #=> false

检查特定项目是否包含在数组中

browsers.include?('Konqueror') #=> false

向数组添加项

可以使用 push 或 << 将项目添加到数组的末尾

arr = [1, 2, 3, 4]
arr.push(5) #=> [1, 2, 3, 4, 5]
arr << 6    #=> [1, 2, 3, 4, 5, 6]

unshift 将在数组的开头添加一个新项目。

arr.unshift(0) #=> [0, 1, 2, 3, 4, 5, 6]

使用 insert ，您可以在数组的任何位置添加新元素。

arr.insert(3, 'apple')  #=> [0, 1, 2, 'apple', 3, 4, 5, 6]

使用 insert 方法，您还可以一次插入多个值：

arr.insert(3, 'orange', 'pear', 'grapefruit')
#=> [0, 1, 2, "orange", "pear", "grapefruit", "apple", 3, 4, 5, 6]

从 Array 中删除项目

方法 pop 删除数组中的最后一个元素并返回它：

arr =  [1, 2, 3, 4, 5, 6]
arr.pop #=> 6
arr #=> [1, 2, 3, 4, 5]

要检索并同时删除第一项，请使用 shift ：

arr.shift #=> 1
arr #=> [2, 3, 4, 5]

要删除特定索引处的元素：

arr.delete_at(2) #=> 4
arr #=> [2, 3, 5]

要删除数组中任意位置的特定元素，请使用 delete ：

arr = [1, 2, 2, 3]
arr.delete(2) #=> 2
arr #=> [1,3]

如果您需要从数组中删除 nil 值，一个有用的方法是 compact ：

arr = ['foo', 0, nil, 'bar', 7, 'baz', nil]
arr.compact  #=> ['foo', 0, 'bar', 7, 'baz']
arr          #=> ['foo', 0, nil, 'bar', 7, 'baz', nil]
arr.compact! #=> ['foo', 0, 'bar', 7, 'baz']
arr          #=> ['foo', 0, 'bar', 7, 'baz']

另一个常见的需求是从数组中删除重复元素。

它具有非破坏性 uniq 和破坏性方法 uniq!

arr = [2, 5, 6, 556, 6, 6, 8, 9, 0, 123, 556]
arr.uniq #=> [2, 5, 6, 556, 8, 9, 0, 123]

遍历数组

像所有包含 Enumerable 模块的类一样， Array 有一个 each 方法，它定义了应该迭代哪些元素以及如何迭代。在 Array 的 each 的情况下， Array 实例中的所有元素都按顺序生成给提供的块。

请注意，此操作使数组保持不变。

arr = [1, 2, 3, 4, 5]
arr.each {|a| print a -= 10, " "}
# prints: -9 -8 -7 -6 -5
#=> [1, 2, 3, 4, 5]

另一个有时有用的迭代器是 reverse_each ，它将以相反的顺序迭代数组中的元素。

words = %w[first second third fourth fifth sixth]
str = ""
words.reverse_each {|word| str += "#{word} "}
p str #=> "sixth fifth fourth third second first "

map 方法可用于基于原始数组创建一个新数组，但其值由提供的块修改：

arr.map {|a| 2*a}     #=> [2, 4, 6, 8, 10]
arr                   #=> [1, 2, 3, 4, 5]
arr.map! {|a| a**2}   #=> [1, 4, 9, 16, 25]
arr                   #=> [1, 4, 9, 16, 25]

从 Array 中选择项目

可以根据块中定义的标准从数组中选择元素。选择可以以破坏性或非破坏性方式发生。虽然破坏性操作会修改调用它们的数组，但非破坏性方法通常会返回一个包含所选元素的新数组，但保持原始数组不变。

无损选择

arr = [1, 2, 3, 4, 5, 6]
arr.select {|a| a > 3}       #=> [4, 5, 6]
arr.reject {|a| a < 3}       #=> [3, 4, 5, 6]
arr.drop_while {|a| a < 4}   #=> [4, 5, 6]
arr                          #=> [1, 2, 3, 4, 5, 6]

破坏性选择

select! 和 reject! 是 select 和 reject 对应的破坏方法

与 select 与 reject 类似， delete_if 和 keep_if 在提供相同块时具有完全相反的结果：

arr.delete_if {|a| a < 4}   #=> [4, 5, 6]
arr                         #=> [4, 5, 6]

arr = [1, 2, 3, 4, 5, 6]
arr.keep_if {|a| a < 4}   #=> [1, 2, 3]
arr                       #=> [1, 2, 3]