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

puts names.size # 傳回 20

puts names.length # 傳回 20

以上執行個體運作輸出結果為：

您可以給數組中的每個元素指派，如下所示：

names = Array.new(4, "mac")

puts "#{names}"

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

nums = Array.new(10) { |e| e = e * 2 }

puts "#{nums}"

數組還有另一種方法，[]，如下所示：

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

數組建立的另一種形式如下所示：

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

在 Ruby 核心子產品中可以有一個隻接收單個參數的 Array 方法，該方法使用一個範圍作為參數來建立一個數字數組：

digits = Array(0..9)

puts "#{digits}"

我們需要有一個 Array 對象的執行個體來調用 Array 方法。下面是建立 Array 對象執行個體的方式：

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

這将傳回一個使用給定對象進行填充的新數組。現在，使用建立的對象，我們可以調用任意可用的方法。例如：

num = digits.at(6)

puts "#{num}"

下面是公共的數組方法（假設 array 是一個 Array 對象）：

序号

方法 & 描述

array & other_array

傳回一個新的數組，包含兩個數組中共同的元素，沒有重複。

array * int [or] array * str

傳回一個新的數組，新數組通過連接配接 self 的 int 副本建立的。帶有 String 參數時，相當于 self.join(str)。

array + other_array

傳回一個新的數組，新數組通過連接配接兩個數組産生第三個數組建立的。

array - other_array

傳回一個新的數組，新數組是從初始數組中移除了在 other_array 中出現的項的副本。

str <=> other_str

把 str 與 other_str 進行比較，傳回 -1（小于）、0（等于）或 1（大于）。比較是區分大小寫的。

array | other_array

通過把 other_array 加入 array 中，移除重複項，傳回一個新的數組。

array << obj

把給定的對象附加到數組的末尾。該表達式傳回數組本身，是以幾個附加可以連在一起。

array <=> other_array

如果數組小于、等于或大于 other_array，則傳回一個整數（-1、 0 或 +1）。

array == other_array

如果兩個數組包含相同的元素個數，且每個元素與另一個數組中相對應的元素相等（根據 Object.==），那麼這兩個數組相等。

array[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。

array[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 删除元素。

array.abbrev(pattern = nil)

為 self 中的字元串計算明确的縮寫集合。如果傳遞一個模式或一個字元串，隻考慮當字元串比對模式或者以該字元串開始時的情況。

array.assoc(obj)

搜尋一個數組，其元素也是數組，使用 obj.== 把 obj 與每個包含的數組的第一個元素進行比較。如果比對則傳回第一個包含的數組，如果未找到比對則傳回 nil。

array.at(index)

傳回索引為 index 的元素。一個負值索引從 self 的末尾開始計數。如果索引超出範圍則傳回 nil。

array.clear

從數組中移除所有的元素。

array.collect { |item| block } [or]

array.map { |item| block }

為 self 中的每個元素調用一次 block。建立一個新的數組，包含 block 傳回的值。

array.collect! { |item| block } [or]

array.map! { |item| block }

為 self 中的每個元素調用一次 block，把元素替換為 block 傳回的值。

array.compact

傳回 self 的副本，移除了所有的 nil 元素。

array.compact!

從數組中移除所有的 nil 元素。如果沒有變化則傳回 nil。

array.concat(other_array)

追加 other_array 中的元素到 self 中。

array.delete(obj) [or]

array.delete(obj) { block }

從 self 中删除等于 obj 的項。如果未找到相等項，則傳回 nil。如果未找到相等項且給出了可選的代碼 block，則傳回 block 的結果。

array.delete_at(index)

删除指定的 index 處的元素，并傳回該元素。如果 index 超出範圍，則傳回 nil。

array.delete_if { |item| block }

當 block 為 true 時，删除 self 的每個元素。

array.each { |item| block }

為 self 中的每個元素調用一次 block，傳遞該元素作為參數。

array.each_index { |index| block }

與 Array#each 相同，但是傳遞元素的 index，而不是傳遞元素本身。

array.empty?

如果數組本身沒有包含元素，則傳回 true。

array.eql?(other)

如果 array 和 other 是相同的對象，或者兩個數組帶有相同的内容，則傳回 true。

array.fetch(index) [or]

array.fetch(index, default) [or]

array.fetch(index) { |index| block }

嘗試傳回位置 index 處的元素。如果 index 位于數組外部，則第一種形式會抛出 IndexError 異常，第二種形式會傳回 default，第三種形式會傳回調用 block 傳入 index 的值。負值的 index 從數組末尾開始計數。

array.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 通過帶有被填充的每個元素的絕對索引來傳遞。

array.first [or]

array.first(n)

傳回數組的第一個元素或前 n 個元素。如果數組為空，則第一種形式傳回 nil，第二種形式傳回一個空的數組。

array.flatten

傳回一個新的數組，新數組是一個一維的扁平化的數組（遞歸）。

array.flatten!

把 array 進行扁平化。如果沒有變化則傳回 nil。（數組不包含子數組。）

array.frozen?

如果 array 被當機（或排序時暫時當機），則傳回 true。

array.hash

計算數組的哈希代碼。兩個具有相同内容的數組将具有相同的哈希代碼。

array.include?(obj)

如果 self 中包含 obj，則傳回 true，否則傳回 false。

array.index(obj)

傳回 self 中第一個等于 obj 的對象的 index。如果未找到比對則傳回 nil。

array.indexes(i1, i2, ... iN) [or]

array.indices(i1, i2, ... iN)

該方法在 Ruby 的最新版本中被廢棄，是以請使用 Array#values_at。

array.indices(i1, i2, ... iN) [or]

array.indexes(i1, i2, ... iN)

array.insert(index, obj...)

在給定的 index 的元素前插入給定的值，index 可以是負值。

array.inspect

建立一個數組的可列印版本。

array.join(sep=$,)

傳回一個字元串，通過把數組的每個元素轉換為字元串，并使用 sep 分隔進行建立的。

array.last [or] array.last(n)

傳回 self 的最後一個元素。如果數組為空，則第一種形式傳回 nil。

array.length

傳回 self 中元素的個數。可能為零。

array.map { |item| block } [or]

array.collect { |item| block }

為 self 的每個元素調用一次 block。建立一個新的數組，包含 block 傳回的值。

array.map! { |item| block } [or]

array.collect! { |item| block }

為 array 的每個元素調用一次 block，把元素替換為 block 傳回的值。

array.nitems

傳回 self 中 non-nil 元素的個數。可能為零。

array.pack(aTemplateString)

根據 aTemplateString 中的指令，把數組的内容壓縮為二進制序列。指令 A、 a 和 Z 後可以跟一個表示結果字段寬度的數字。剩餘的指令也可以帶有一個表示要轉換的數組元素個數的數字。如果數字是一個星号（*），則所有剩餘的數組元素都将被轉換。任何指令後都可以跟一個下劃線（_），表示指定類型使用底層平台的本地尺寸大小，否則使用獨立于平台的一緻的尺寸大小。在模闆字元串中空格會被忽略。

array.pop

從 array 中移除最後一個元素，并傳回該元素。如果 array 為空則傳回 nil。

array.push(obj, ...)

把給定的 obj 附加到數組的末尾。該表達式傳回數組本身，是以幾個附加可以連在一起。

array.rassoc(key)

搜尋一個數組，其元素也是數組，使用 == 把 key 與每個包含的數組的第二個元素進行比較。如果比對則傳回第一個包含的數組。

array.reject { |item| block }

傳回一個新的數組，包含當 block 不為 true 時的數組項。

array.reject! { |item| block }

當 block 為真時，從 array 删除元素，如果沒有變化則傳回 nil。相當于 Array#delete_if。

array.replace(other_array)

把 array 的内容替換為 other_array 的内容，必要的時候進行截斷或擴充。

array.reverse

傳回一個新的數組，包含倒序排列的數組元素。

array.reverse!

把 array 進行逆轉。

array.reverse_each {|item| block }

與 Array#each 相同，但是把 array 進行逆轉。

array.rindex(obj)

傳回 array 中最後一個等于 obj 的對象的索引。如果未找到比對，則傳回 nil。

array.select {|item| block }

調用從數組傳入連續元素的 block，傳回一個數組，包含 block 傳回 true 值時的元素。

array.shift

傳回 self 的第一個元素，并移除該元素（把所有的其他元素下移一位）。如果數組為空，則傳回 nil。

array.size

傳回 array 的長度（元素的個數）。length 的别名。

array.slice(index) [or] array.slice(start, length) [or]

array.slice(range) [or] array[index] [or]

array[start, length] [or] array[range]

array.slice!(index) [or] array.slice!(start, length) [or]

array.slice!(range)

删除 index（長度是可選的）或 range 指定的元素。傳回被删除的對象、子數組，如果 index 超出範圍，則傳回 nil。

array.sort [or] array.sort { | a,b | block }

傳回一個排序的數組。

array.sort! [or] array.sort! { | a,b | block }

把數組進行排序。

array.to_a

傳回 self。如果在 Array 的子類上調用，則把接收參數轉換為一個 Array 對象。

array.to_ary

傳回 self。

array.to_s

傳回 self.join。

array.transpose

假設 self 是數組的數組，且置換行和列。

array.uniq

傳回一個新的數組，移除了 array 中的重複值。

array.uniq!

從 self 中移除重複元素。如果沒有變化（也就是說，未找到重複），則傳回 nil。

array.unshift(obj, ...)

把對象前置在數組的前面，其他元素上移一位。

array.values_at(selector,...)

傳回一個數組，包含 self 中與給定的 selector（一個或多個）相對應的元素。選擇器可以是整數索引或者範圍。

array.zip(arg, ...) [or]

array.zip(arg, ...){ | arr | block }

把任何參數轉換為數組，然後把 array 的元素與每個參數中相對應的元素合并。

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

指令

描述

移動到絕對位置。

ASCII 字元串（填充 space，count 是寬度）。

ASCII 字元串（填充 null，count 是寬度）。

位字元串（降序）

位字元串（升序）。

無符号字元。

字元。

D, d

雙精度浮點數，原生格式。

雙精度浮點數，little-endian 位元組順序。

單精度浮點數，little-endian 位元組順序。

F, f

單精度浮點數，原生格式。

雙精度浮點數，network（big-endian）位元組順序。

單精度浮點數，network（big-endian）位元組順序。

十六進制字元串（高位優先）。

十六進制字元串（低位優先）。

無符号整數。

整數。

無符号 long。

Long。

引用可列印的，MIME 編碼。

Base64 編碼字元串。

Long，network（big-endian）位元組順序。

Short，network（big-endian）位元組順序。

指向一個結構（固定長度的字元串）。

指向一個空結束字元串。

Q, q

64 位數字。

無符号 short。

Short。

UTF-8。

UU 編碼字元串。

Long，little-endian 位元組順序。

Short，little-endian 位元組順序。

BER 壓縮的整數 \fnm。

向後跳過一個位元組。

Null 位元組。

與 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"