Ruby - 数组

Ruby数组是任何对象的有序整数索引集合.数组中的每个元素都与索引关联并由索引引用.

数组索引从0开始,如在C或Java中.假定相对于数组末尾的负索引 - 也就是说,索引-1表示数组的最后一个元素,-2是数组中最后一个元素的倒数,依此类推.

Ruby数组可以包含String,Integer,Fixnum,Hash,Symbol等对象,甚至包含其他Array对象. Ruby数组不像其他语言中的数组那样严格. Ruby数组在向其添加元素时自动增长.

创建数组

创建或初始化数组的方法有很多种.一种方法是使用 new 类方法 :

names = Array.new

您可以在创建数组时设置数组的大小 :

names = Array.new(20)

数组名称现在的大小或长度为20个元素.您可以使用大小或长度方法返回数组的大小 :

#!/usr/bin/ruby

names = Array.new(20)
puts names.size  # This returns 20
puts names.length # This also returns 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]

还有另一种Array方法,[].它的工作原理如下:<

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

另一种形式的数组创建如下 :

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

核心Ruby中可用的 Kernel 模块有一个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

Sr.No.方法&说明
1

array & other_array

返回一个新数组,其中包含两个数组共有的元素,没有重复项.

2

array * int [或] array * str

返回通过连接self的int副本构建的新数组.使用String参数,相当于self.join(str).

3

array&plus; other_array

返回通过将两个数组连接在一起以生成第三个数组而构建的新数组.

4

array  -  other_array

返回一个新数组,它是原始数组的副本,删除也出现在other_array中的所有项.

5

array < => other_array

将str与other_str进行比较,返回-1(小于),0(等于)或1(大于).比较是区分大小写的.

6

array | other_array

通过将数组与other_array连接,删除重复项来返回一个新数组.

7

array << obj

将给定对象推送到数组的末尾.此表达式返回数组本身,因此可以将多个附加链接在一起.

8

array < => other_array

如果此数组小于,等于或大于other_array,则返回一个整数(-1,0或+1).

9

array == other_array

如果两个数组包含相同数量的元素并且每个元素等于(根据Object.==)另一个数组中的相应元素,则它们是相等的.

10

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 元素的子数组,或返回由范围的.负索引从数组末尾向后计数(-1是最后一个元素).如果索引(或起始索引)超出范围,则返回 nil .

11

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 中的元素.

12

array.abbrev(pattern = nil)

计算 self 中字符串的明确缩写集.如果传递模式或字符串,则只考虑匹配模式或以字符串开头的字符串.

13

array.assoc(obj)

搜索数组其元素也是使用obj.==将obj与每个包含数组的第一个元素进行比较的数组.如果没有匹配,则返回匹配的第一个包含的数组或 nil .

14

array.at(index)

返回元素at指数.负指数从自我结束开始计算.如果索引超出范围,则返回nil.

15

array.clear

从数组中删除所有元素.

16

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

array.map { |item| block }

self 的每个元素调用一次block.创建一个包含块返回值的新数组.

17

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

array.map! { |item| block }

self 的每个元素调用 block 一次,用

18

array.compact

返回所有 nil self 的副本元素已删除.

19

array.compact!

从数组中删除 nil 元素.如果没有做出任何更改,则返回 nil .

20

array.concat(other_array)

将other_array中的元素追加到 self .

21

array.delete(obj) [or]

array.delete(obj) { block }

删除 self 中等于 obj 的项目.如果找不到该项,则返回 nil .如果给出了可选代码,如果找不到该项,则返回的结果.

22

array.delete_at(index)

删除指定索引的元素,返回该元素,如果索引超出范围,则删除 nil .

23

array.delete_if {| item | block}

删除 block 评估为真的 self 的每个元素.

24

array.each { |item| block }

self 中的每个元素调用阻止一次,将该元素作为参数传递.

25

array.each_index {| index | block}

与Array#each相同,但是传递元素的索引而不是元素本身.

26

array.empty?

如果self数组不包含任何元素,则返回true.

27

array.eql?(other)

如果 array other 是同一个对象,或者两个数组都具有相同的内容,则返回true.

28

array.fetch(index) [or]

array.fetch(index, default) [or]

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

尝试返回位置 index 的元素.如果 index 位于数组之外,则第一个表单抛出 IndexError 异常,第二个表单返回 default ,第三个表单返回值调用,传入索引. index 的负值从数组的末尾开始计算.

29

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 .最后三个形式用块的值填充数组. 与每个要填充的元素的绝对索引一起传递.

30

array.first [or]

array.first(n)

返回数组的第一个元素或第一个 n 元素.如果数组为空,则第一个表单返回 nil ,第二个表单返回一个空数组.

31

array.flatten

退货一个新数组,它是这个数组的一维展平(递归).

32

array.flatten!

展平数组 .如果没有进行任何修改,则返回 nil . (数组不包含子数组.)

33

array.frozen?

如果数组被冻结(或在排序时暂时冻结),则返回true .

34

array.hash

计算数组的哈希码.具有相同内容的两个数组将具有相同的哈希码.

35

array.include?(obj)

如果 obj 是,则返回true出现在 self 中,否则为false.

36

array.index(obj)

返回索引 self 中的第一个对象是== to obj.如果没有找到匹配,则返回 nil .

37

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

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

在最新版本的Ruby中不推荐使用此方法,因此请使用Array#values_at.

38

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

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

在最新版本的Ruby中不推荐使用此方法,因此请使用Array#values_at.

39

array.insert(index,obj ...)

在具有给定索引的元素之前插入给定值(可能是负数).

40

array.inspect

创建数组的可打印版本.

41

array.join( sep =&dollar;,)

返回通过将数组的每个元素转换为字符串而创建的字符串,由 sep 分隔.

42

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

返回 self 的最后一个元素.如果数组为空,则第一个表单返回 nil .

43

array.length

返回的数量 self 中的元素.可能为零.

44

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

array.collect { |item| block }

self 的每个元素调用阻止一次.创建一个 new 数组,其中包含块返回的值.

45

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

array.collect! { |item| block }

array 的每个元素调用 block 一次,用block返回的值替换该元素.

46

array.nitems

返回 self 中非零元素的数量.可能为零.

47

array.pack(aTemplateString)

根据TemplateString中的指令将数组内容打包成二进制序列.指令A,a和Z后面可以跟一个计数,它给出了结果字段的宽度.其余指令也可能需要计数,表示要转换的数组元素的数量.如果计数是星号(*),则将转换所有剩余的数组元素.任何指令仍然可以后跟下划线(_)以使用底层平台的指定类型的本机大小;否则,他们使用独立于平台的大小.模板字符串中将忽略空格.

48

array.pop

数组中删除最后一个元素并将其返回,或 nil 如果数组为空.

49

array.push(obj,...)

推(追加)将obj赋予此数组的末尾.此表达式返回数组本身,因此可以将多个附加链接在一起.

50

array.rassoc(key)

搜索其元素也是数组的数组.使用==将 key 与每个包含的数组的第二个元素进行比较.返回匹配的第一个包含的数组.

51

array.reject {| item | block}

返回一个新数组,其中包含块 array ,其块不是 true .

52

array.reject! {| item |块}

数组中删除块,其值为 true ,但返回 nil 如果没有进行任何更改.相当于Array#delete_if.

53

array.replace(other_array)

other_array的内容替换 array 的内容,必要时截断或扩展.

54

array.reverse

以相反的顺序返回包含数组元素的新数组.

55

array.reverse!

反转数组.

56

array.reverse_each {| item | block}

与Array#each相同,但是以相反的顺序遍历 array .

57

array.rindex(obj)

返回array == to obj中最后一个对象的索引.如果没有找到匹配,则返回 nil .

58

array.select {| item | block}

调用从数组传递连续元素的块,返回一个包含块返回 true 值的元素的数组./p>

59

array.shift

返回 self 的第一个元素并将其删除(将所有其他元素向下移动一个).如果数组为空,则返回 nil .

60

array.size

返回数组的长度(数字)元素).长度的别名.

61

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

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

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

返回 index 处的元素,或返回从 start 开始并继续 length 元素的子数组,或返回范围指定的子阵列.负索引从数组末尾向后计数(-1是最后一个元素).如果索引(或起始索引)超出范围,则返回 nil .

62

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

array.slice!(range)

删除元素由索引(可选地具有长度)或由范围给出.如果 index 超出范围,则返回已删除的对象,子数组或 nil .

63

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

返回通过排序self创建的新数组.

64

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

自行排序.

65

array.to_a

返回 self .如果在 Array 的子类上调用,则将接收器转换为Array对象.

66

array.to_ary

返回self.

67

array.to_s

返回self.join.

68

array.transpose

假设self是一个数组数组和转置行和列.

69

array.uniq

通过删除 array 中的重复值来返回一个新数组.

70

array.uniq!

self 中删除重复的元素.如果没有做出任何更改,则返回 nil (即,没有找到重复项).

71

array.unshift(obj,...)

将对象添加到数组的前面,将其他元素添加到一个.

72

array.values_at(selector,...)

返回包含元素的数组self对应于给定的选择器(一个或多个).选择器可以是整数索引或范围.

73

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

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

将任何参数转换为数组,然后将 array 的元素与每个参数中的相应元素合并.

数据包指令

Sr.No.指令&说明
1

@

移动到绝对位置.

2

A

ASCII字符串(空格填充,计数是宽度).

3

a

ASCII字符串(空填充,计数是宽度).

4

B

string(降序位).

5

b

位串(升序位).

6

C

无符号字符.

7

c

Char.

8

D,d

Double -precision float,native format.

9

E

双精度浮点数,小端字节顺序.

10

e

单精度浮点数,小端字节顺序.

11

F,f

单精度浮点数,原生格式.

12

G

双精度浮点数,网络(大-endian)字节顺序.

13

g

单精度浮点数,网络(大端)字节顺序.

14

H

十六进制字符串(高半字节优先).

15

h

十六进制字符串(低半字节优先).

16
17

i

整数.

18

L

无符号长.

19

l

长.

20

M

引用可打印的MIME编码(参见RFC 2045).

21

m

Base64编码的字符串.

22

N

长,网络(大端)字节顺序.

23

n

短,网络(大 - 字节顺序.

24

P

指向结构的指针(固定长度字符串).

25

p

指向以null结尾的字符串的指针.

26

Q,q

64位数字.

27

S

无符号空头.

28

s

短.

29

U

UTF-8.

30

u

UU编码的字符串.

31

V

长,小端字节顺序.

32

v

短小端字节顺序.

33

w

BER压缩整数\ fnm.

34

X

备份一个字节.

35

x

空字节.

36

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