top
Loading...
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)
如果 arrayother 是相同的對象,或者兩個數組帶有相同的內容,則返回 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
北斗有巢氏 有巢氏北斗