Ruby - 数组

array & other_array

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

array * int [or] 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

通过将 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个元素的子数组，或返回由<指定的子数组 i>范围。 负索引从数组末尾向后计数（-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个元素的子数组，或替换由<指定的子数组 i>范围。 如果索引大于数组的当前容量，则数组会自动增长。 负索引将从数组末尾向后计数。 如果 length 为零，则插入元素。 如果在第二种和第三种形式中使用了 nil，则从 self 中删除元素。

array.abbrev(pattern = nil)

计算self 中字符串的明确缩写集。 如果传递了模式或字符串，则仅考虑与模式匹配或以字符串开头的字符串。

array.assoc(obj)

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

array.at(index)

返回索引处的元素。 负索引从 self 的末尾开始计数。 如果索引超出范围，则返回 nil。

array.clear

从数组中删除所有元素。

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

array.map { |item| block }

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

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 处的元素，返回该元素，如果索引超出范围，则返回 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?

如果 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，第三种形式返回 调用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 与要填充的每个元素的绝对索引一起传递。

array.first [or]

array.first(n)

返回数组的第一个元素，或前 n 个元素。 如果数组为空，第一种形式返回nil，第二种形式返回空数组。

array.flatten

返回一个新数组，它是该数组的一维展平（递归）。

array.flatten!

扁平化数组。 如果没有进行任何修改，则返回 nil。 （数组不包含子数组。）

array.frozen?

如果 array 被冻结（或在排序时暂时冻结），则返回 true。

array.hash

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

array.include?(obj)

如果 obj 存在于 self 中，则返回 true，否则返回 false。

array.index(obj)

返回 self 中第一个对象的 index，即 == 给 obj。 如果未找到匹配项，则返回 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)

此方法在最新版本的 Ruby 中已弃用，因此请使用 Array#values_at。

array.insert(index, obj...)

在具有给定 index 的元素之前插入给定值（可能为负数）。

array.inspect

创建数组的可打印版本。

array.join(sep = $,)

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

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

返回 self 的最后一个元素。 如果数组是empty，第一种形式返回nil。

array.length

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

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

array.collect { |item| block }

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

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

array.collect! { |item| block }

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

array.nitems

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

array.pack(aTemplateString)

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

array.pop

从 array 中删除最后一个元素并返回它，如果 array 为空，则返回 nil。

array.push(obj, ...)

将给定的 obj 推送（附加）到此数组的末尾。 此表达式返回数组本身，因此可以将多个追加链接在一起。

array.rassoc(key)

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

array.reject { |item| block }

Returns a new array containing the items array for which the block is not true.

array.reject! { |item| block }

从 array 中删除块评估为 true 的元素，但如果未进行任何更改，则返回 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)

将数组 == 中最后一个对象的索引返回给 obj。 如果未找到匹配项，则返回 nil。

array.select {|item| block }

调用从数组中传入连续元素的块，返回一个数组，其中包含块为其返回 true 值的那些元素。

array.shift

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

array.size

返回 array 的长度（元素数）。 长度的别名。

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个元素的子数组，或返回由<指定的子数组 i>范围。 负索引从数组末尾向后计数（-1 是最后一个元素）。 如果 index（或起始索引）超出范围，则返回 nil。

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 中的元素。 选择器可以是整数索引或范围。

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

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

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

@

移动到绝对位置。

A

ASCII 字符串（空格填充，计数是宽度）。

a

ASCII 字符串（空填充，计数为宽度）。

B

字符串（降序位顺序）。

b

位串（升序位）。

C

无符号字符。

c

字符。

D, d

双精度浮点数，原生格式。

E

双精度浮点，little-endian 字节序。

e

单精度浮点， little-endian 字节序。

F, f

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

G

双精度浮点数，网络（big-endian）字节顺序。

g

单精度浮点数，网络（big-endian）字节顺序。

H

十六进制字符串（高位在前）。

h

十六进制字符串（低位优先）。

I

无符号整数。

i

整数。

L

无符号长整数。

l

长整数

M

引用的可打印 MIME 编码（请参阅 RFC 2045）。

m

Base64 编码的字符串。

N

Long, 网络 (big-endian) 字节顺序。

n

Short, 网络 (big-endian) 字节顺序。

P

指向结构的指针（固定长度的字符串）。

p

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

Q, q

64 位数字。

S

Unsigned short.

s

Short.

U

UTF-8 编码

u

UU 编码的字符串。

V

Long, little-endian 字节顺序。

v

Short, little-endian 字节顺序。

w

BER 压缩整数 ffnm。

X

备份一个字节。

x

Null 空字节。

Z

与a相同，只是null加上*。