Ruby - 数组

array & other_array

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

array * int [或] array * str

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

array+ other_array

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

array  -  other_array

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

array < => other_array

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

array | other_array

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

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

array.clear

从数组中删除所有元素.

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

array.map { |item| block }

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

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

array.map! { |item| block }

为 self 的每个元素调用 block 一次，用

array.compact

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

array.compact！

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

array.concat(other_array)

将other_array中的元素追加到 self .

array.delete(obj) [or]

array.delete(obj) { block }

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

array.delete_at(index)

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

array.delete_if {| item | block}

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

array.each { |item| block }

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

array.each_index {| index | block}

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

array.empty？

如果self数组不包含任何元素，则返回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 ，第三个表单返回值调用块，传入索引. 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 .最后三个形式用块的值填充数组. 块与每个要填充的元素的绝对索引一起传递.

array.first [or]

array.first(n)

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

array.flatten

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

array.flatten！

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

array.frozen？

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

array.hash

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

array.include？(obj)

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

array.index(obj)

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

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

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

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

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

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

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

array.insert(index，obj ...)

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

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 的每个元素调用阻止一次.创建一个 new 数组，其中包含块返回的值.

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

array.collect! { |item| block }

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

array.nitems

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

array.pack(aTemplateString)

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

array.pop

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

array.push(obj，...)

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

array.rassoc(key)

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

array.reject {| item | block}

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

array.reject！ {| item |块}

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

array.replace(other_array)

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

array.reverse

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

array.reverse！

反转数组.

array.reverse_each {| item | block}

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

array.rindex(obj)

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

array.select {| item | block}

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

array.shift

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

array.size

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

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 .

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

array.slice!(range)

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

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

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

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对应于给定的选择器(一个或多个).选择器可以是整数索引或范围.

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

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

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

@

移动到绝对位置.

A

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

a

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

B

string(降序位).

b

位串(升序位).

C

无符号字符.

c

Char.

D，d

Double -precision float，native format.

E

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

e

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

F，f

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

G

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

g

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

H

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

h

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

i

整数.

L

无符号长.

l

长.

M

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

m

Base64编码的字符串.

N

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

n

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

P

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

p

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

Q，q

64位数字.

S

无符号空头.

s

短.

U

UTF-8.

u

UU编码的字符串.

V

长，小端字节顺序.

v

短小端字节顺序.

w

BER压缩整数\ fnm.

X

备份一个字节.

x

空字节.

Z

与a相同，但null与*一起添加.