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]