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