Ruby 陣列（Array）

Ruby 陣列（Array）

Ruby 陣列是任何物件的有序整數索引集合。陣列中的每個元素都與一個索引相關，並可通過索引進行獲取。

陣列的索引從 0 開始，這與 C 或 Java 中一樣。一個負數的索相對於陣列的末尾計數的，也就是說，索引為 -1 表示陣列的最後一個元素，-2 表示陣列中的倒數第二個元素，依此類推。

Ruby 陣列可儲存諸如 String、 Integer、 Fixnum、 Hash、 Symbol 等物件，甚至可以是其他 Array 物件。

Ruby 陣列不需要指定大小，當向陣列新增元素時，Ruby 陣列會自動增長。

建立陣列

有多種方式建立或初始化陣列。一種方式是通過 new 類方法：

names = Array.new

您可以在建立陣列的同時設定陣列的大小：

names = Array.new(20)

陣列 names 的大小或長度為 20 個元素。您可以使用 size 或 length 方法返回陣列的大小：

例項

#!/usr/bin/ruby names = Array.new(20) puts names.size # 返回 20 puts names.length # 返回 20

嘗試一下 ?

以上例項執行輸出結果為：

20
20

您可以給陣列中的每個元素賦值，如下所示：

例項

#!/usr/bin/ruby names = Array.new(4, "mac") puts "#{names}"

嘗試一下 ?

以上例項執行輸出結果為：

["mac", "mac", "mac", "mac"]

您也可以使用帶有 new 的塊，每個元素使用塊中的計算結果來填充：

例項

#!/usr/bin/ruby nums = Array.new(10) { |e| e = e * 2 } puts "#{nums}"

嘗試一下 ?

以上例項執行輸出結果為：

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

陣列還有另一種方法，[]，如下所示：

nums = Array.[](1, 2, 3, 4,5)

陣列建立的另一種形式如下所示：

nums = Array[1, 2, 3, 4,5]

在 Ruby 核心模組中可以有一個只接收單個引數的 Array 方法，該方法使用一個範圍作為引數來建立一個數字陣列：

例項

#!/usr/bin/ruby digits = Array(0..9) puts "#{digits}"

以上例項執行輸出結果為：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

陣列內建方法

我們需要有一個 Array 物件的例項來呼叫 Array 方法。下面是建立 Array 物件例項的方式：

Array.[](...) [or] Array[...] [or] [...]

這將返回一個使用給定物件進行填充的新陣列。現在，使用建立的物件，我們可以呼叫任意可用的方法。例如：

例項

#!/usr/bin/ruby digits = Array(0..9) num = digits.at(6) puts "#{num}"

以上例項執行輸出結果為：

6

下面是公共的陣列方法（假設 array 是一個 Array 物件）：

序號方法 & 描述
1array & other_array
返回一個新的陣列，包含兩個陣列中共同的元素，沒有重複。
2array * int [or] array * str
返回一個新的陣列，新陣列通過連線 self 的 int 副本建立的。帶有 String 引數時，相當於 self.join(str)。
3array + other_array
返回一個新的陣列，新陣列通過連線兩個陣列產生第三個陣列建立的。
4array - other_array
返回一個新的陣列，新陣列是從初始陣列中移除了在 other_array 中出現的項的副本。
5str <=> other_str
把 str 與 other_str 進行比較，返回 -1（小於）、0（等於）或 1（大於）。比較是區分大小寫的。
6array | other_array
通過把 other_array 加入 array 中，移除重複項，返回一個新的陣列。
7array << obj
把給定的物件附加到陣列的末尾。該表示式返回陣列本身，所以幾個附加可以連在一起。
8array <=> other_array
如果陣列小於、等於或大於 other_array，則返回一個整數（-1、 0 或 +1）。
9array == other_array
如果兩個陣列包含相同的元素個數，且每個元素與另一個數組中相對應的元素相等（根據 Object.==），那麼這兩個陣列相等。
10array[index] [or] array[start, length] [or]
array[range] [or] array.slice(index) [or]
array.slice(start, length) [or] array.slice(range)
返回索引為 index 的元素，或者返回從 start 開始直至 length 個元素的子陣列，或者返回 range 指定的子陣列。負值索引從陣列末尾開始計數（-1 是最後一個元素）。如果 index（或開始索引）超出範圍，則返回 nil。
11array[index] = obj [or]
array[start, length] = obj or an_array or nil [or]
array[range] = obj or an_array or nil
設定索引為 index 的元素，或者替換從 start 開始直至 length 個元素的子陣列，或者替換 range 指定的子陣列。如果索引大於陣列的當前容量，那麼陣列會自動增長。負值索引從陣列末尾開始計數。如果 length 為零則插入元素。如果在第二種或第三種形式中使用了 nil，則從 self 刪除元素。
12array.abbrev(pattern = nil)
為 self 中的字串計算明確的縮寫集合。如果傳遞一個模式或一個字串，只考慮當字串匹配模式或者以該字串開始時的情況。
13array.assoc(obj)
搜尋一個數組，其元素也是陣列，使用 obj.== 把 obj 與每個包含的陣列的第一個元素進行比較。如果匹配則返回第一個包含的陣列，如果未找到匹配則返回 nil。
14array.at(index)
返回索引為 index 的元素。一個負值索引從 self 的末尾開始計數。如果索引超出範圍則返回 nil。
15array.clear
從陣列中移除所有的元素。
16array.collect { |item| block } [or]
array.map { |item| block }
為 self 中的每個元素呼叫一次 block。建立一個新的陣列，包含 block 返回的值。
17array.collect! { |item| block } [or]
array.map! { |item| block }
為 self 中的每個元素呼叫一次 block，把元素替換為 block 返回的值。
18array.compact
返回 self 的副本，移除了所有的 nil 元素。
19array.compact!
從陣列中移除所有的 nil 元素。如果沒有變化則返回 nil。
20array.concat(other_array)
追加 other_array 中的元素到 self 中。
21array.delete(obj) [or]
array.delete(obj) { block }
從 self 中刪除等於 obj 的項。如果未找到相等項，則返回 nil。如果未找到相等項且給出了可選的程式碼 block，則返回 block 的結果。
22array.delete_at(index)
刪除指定的 index 處的元素，並返回該元素。如果 index 超出範圍，則返回 nil。
23array.delete_if { |item| block }
當 block 為 true 時，刪除 self 的每個元素。
24array.each { |item| block }
為 self 中的每個元素呼叫一次 block，傳遞該元素作為引數。
25array.each_index { |index| block }
與 Array#each 相同，但是傳遞元素的 index，而不是傳遞元素本身。
26array.empty?
如果陣列本身沒有包含元素，則返回 true。
27array.eql?(other)
如果 array 和 other 是相同的物件，或者兩個陣列帶有相同的內容，則返回 true。
28array.fetch(index) [or]
array.fetch(index, default) [or]
array.fetch(index) { |index| block }
嘗試返回位置 index 處的元素。如果 index 位於陣列外部，則第一種形式會丟擲 IndexError 異常，第二種形式會返回 default，第三種形式會返回呼叫 block 傳入 index 的值。負值的 index 從陣列末尾開始計數。
29array.fill(obj) [or]
array.fill(obj, start [, length]) [or]
array.fill(obj, range) [or]
array.fill { |index| block } [or]
array.fill(start [, length] ) { |index| block } [or]
array.fill(range) { |index| block }
前面三種形式設定 self 的被選元素為 obj。以 nil 開頭相當於零。nil 的長度相當於 self.length。最後三種形式用 block 的值填充陣列。block 通過帶有被填充的每個元素的絕對索引來傳遞。
30array.first [or]
array.first(n)
返回陣列的第一個元素或前 n 個元素。如果陣列為空，則第一種形式返回 nil，第二種形式返回一個空的陣列。
31array.flatten
返回一個新的陣列，新陣列是一個一維的扁平化的陣列（遞迴）。
32array.flatten!
把 array 進行扁平化。如果沒有變化則返回 nil。（陣列不包含子陣列。）
33array.frozen?
如果 array 被凍結（或排序時暫時凍結），則返回 true。
34array.hash
計算陣列的雜湊程式碼。兩個具有相同內容的陣列將具有相同的雜湊程式碼。
35array.include?(obj)
如果 self 中包含 obj，則返回 true，否則返回 false。
36array.index(obj)
返回 self 中第一個等於 obj 的物件的 index。如果未找到匹配則返回 nil。
37array.indexes(i1, i2, ... iN) [or]
array.indices(i1, i2, ... iN)
該方法在 Ruby 的最新版本中被廢棄，所以請使用 Array#values_at。
38array.indices(i1, i2, ... iN) [or]
array.indexes(i1, i2, ... iN)
該方法在 Ruby 的最新版本中被廢棄，所以請使用 Array#values_at。
39array.insert(index, obj...)
在給定的 index 的元素前插入給定的值，index 可以是負值。
40array.inspect
建立一個數組的可列印版本。
41array.join(sep=$,)
返回一個字串，通過把陣列的每個元素轉換為字串，並使用 sep 分隔進行建立的。
42array.last [or] array.last(n)
返回 self 的最後一個元素。如果陣列為空，則第一種形式返回 nil。
43array.length
返回 self 中元素的個數。可能為零。
44array.map { |item| block } [or]
array.collect { |item| block }
為 self 的每個元素呼叫一次 block。建立一個新的陣列，包含 block 返回的值。
45array.map! { |item| block } [or]
array.collect! { |item| block }
為 array 的每個元素呼叫一次 block，把元素替換為 block 返回的值。
46array.nitems
返回 self 中 non-nil 元素的個數。可能為零。
47array.pack(aTemplateString)
根據 aTemplateString 中的指令，把陣列的內容壓縮為二進位制序列。指令 A、 a 和 Z 後可以跟一個表示結果欄位寬度的數字。剩餘的指令也可以帶有一個表示要轉換的陣列元素個數的數字。如果數字是一個星號（*），則所有剩餘的陣列元素都將被轉換。任何指令後都可以跟一個下劃線（_），表示指定型別使用底層平臺的本地尺寸大小，否則使用獨立於平臺的一致的尺寸大小。在模板字串中空格會被忽略。
48array.pop
從 array 中移除最後一個元素，並返回該元素。如果 array 為空則返回 nil。
49array.push(obj, ...)
把給定的 obj 附加到陣列的末尾。該表示式返回陣列本身，所以幾個附加可以連在一起。
50array.rassoc(key)
搜尋一個數組，其元素也是陣列，使用 == 把 key 與每個包含的陣列的第二個元素進行比較。如果匹配則返回第一個包含的陣列。
51array.reject { |item| block }
返回一個新的陣列，包含當 block 不為 true 時的陣列項。
52array.reject! { |item| block }
當 block 為真時，從 array 刪除元素，如果沒有變化則返回 nil。相當於 Array#delete_if。
53array.replace(other_array)
把 array 的內容替換為 other_array 的內容，必要的時候進行截斷或擴充。
54array.reverse
返回一個新的陣列，包含倒序排列的陣列元素。
55array.reverse!
把 array 進行逆轉。
56array.reverse_each {|item| block }
與 Array#each 相同，但是把 array 進行逆轉。
57array.rindex(obj)
返回 array 中最後一個等於 obj 的物件的索引。如果未找到匹配，則返回 nil。
58array.select {|item| block }
呼叫從陣列傳入連續元素的 block，返回一個數組，包含 block 返回 true 值時的元素。
59array.shift
返回 self 的第一個元素，並移除該元素（把所有的其他元素下移一位）。如果陣列為空，則返回 nil。
60array.size
返回 array 的長度（元素的個數）。length 的別名。
61array.slice(index) [or] array.slice(start, length) [or]
array.slice(range) [or] array[index] [or]
array[start, length] [or] array[range]
返回索引為 index 的元素，或者返回從 start 開始直至 length 個元素的子陣列，或者返回 range 指定的子陣列。負值索引從陣列末尾開始計數（-1 是最後一個元素）。如果 index（或開始索引）超出範圍，則返回 nil。
62array.slice!(index) [or] array.slice!(start, length) [or]
array.slice!(range)
刪除 index（長度是可選的）或 range 指定的元素。返回被刪除的物件、子陣列，如果 index 超出範圍，則返回 nil。
63array.sort [or] array.sort { | a,b | block }
返回一個排序的陣列。
64array.sort! [or] array.sort! { | a,b | block }
把陣列進行排序。
65array.to_a
返回 self。如果在 Array 的子類上呼叫，則把接收引數轉換為一個 Array 物件。
66array.to_ary
返回 self。
67array.to_s
返回 self.join。
68array.transpose
假設 self 是陣列的陣列，且置換行和列。
69array.uniq
返回一個新的陣列，移除了 array 中的重複值。
70array.uniq!
從 self 中移除重複元素。如果沒有變化（也就是說，未找到重複），則返回 nil。
71array.unshift(obj, ...)
把物件前置在陣列的前面，其他元素上移一位。
72array.values_at(selector,...)
返回一個數組，包含 self 中與給定的 selector（一個或多個）相對應的元素。選擇器可以是整數索引或者範圍。
73array.zip(arg, ...) [or]
array.zip(arg, ...){ | arr | block }
把任何引數轉換為陣列，然後把 array 的元素與每個引數中相對應的元素合併。

陣列 pack 指令

下表列出了方法 Array#pack 的壓縮指令。

指令描述
@移動到絕對位置。
AASCII 字串（填充 space，count 是寬度）。
aASCII 字串（填充 null，count 是寬度）。
B位字串（降序）
b位字串（升序）。
C無符號字元。
c字元。
D, d雙精度浮點數，原生格式。
E雙精度浮點數，little-endian 位元組順序。
e單精度浮點數，little-endian 位元組順序。
F, f單精度浮點數，原生格式。
G雙精度浮點數，network（big-endian）位元組順序。
g單精度浮點數，network（big-endian）位元組順序。
H十六進位制字串（高位優先）。
h十六進位制字串（低位優先）。
I無符號整數。
i整數。
L無符號 long。
lLong。
M引用可列印的，MIME 編碼。
mBase64 編碼字串。
NLong，network（big-endian）位元組順序。
nShort，network（big-endian）位元組順序。
P指向一個結構（固定長度的字串）。
p指向一個空結束字串。
Q, q64 位數字。
S無符號 short。
sShort。
UUTF-8。
uUU 編碼字串。
VLong，little-endian 位元組順序。
vShort，little-endian 位元組順序。
wBER 壓縮的整數 \fnm。
X向後跳過一個位元組。
xNull 位元組。
Z與 a 相同，除了 null 會被加上 *。

例項

嘗試下面的例項，壓縮各種資料。

例項

a = [ "a", "b", "c" ] n = [ 65, 66, 67 ] puts a.pack("A3A3A3") #=> "a b c " puts a.pack("a3a3a3") #=> "a\000\000b\000\000c\000\000" puts n.pack("ccc") #=> "ABC"

以上例項執行輸出結果為：

a  b  c
abc
ABC