Ruby - 数组

array & other_array

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

array * int [或] array * str

返回一个新数组，该数组通过连接 self 的 int 个副本构建而成。对于字符串参数，等效于 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 的末尾。此表达式返回数组本身，因此可以将多个追加链接在一起。

array <=> other_array

如果此数组小于、等于或大于 other_array，则返回一个整数（-1、0 或 +1）。

array == other_array

如果两个数组包含相同数量的元素，并且每个元素都等于（根据 Object.==）另一个数组中的对应元素，则这两个数组相等。

array[index] [或] array[start, length] [或]

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

array.slice(start, length) [或] array.slice(range)

返回 index 处的元素，或返回从 start 开始并继续 length 个元素的子数组，或返回由 range 指定的子数组。负索引从数组的末尾反向计数（-1 是最后一个元素）。如果索引（或起始索引）超出范围，则返回 nil。

array[index] = obj [或]

array[start, length] = obj 或 an_array 或 nil [或]

array[range] = obj 或 an_array 或 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 中删除所有元素。

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

array.map { |item| block }

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

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

array.map! { |item| block }

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

array.compact

返回 self 的副本，其中所有 nil 元素都已删除。

array.compact!

从 array 中删除 nil 元素。如果未进行任何更改，则返回 nil。

array.concat(other_array)

将 other_array 中的元素附加到 self。

array.delete(obj) [或]

array.delete(obj) { block }

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

array.delete_at(index)

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

array.delete_if { |item| block }

删除 self 的每个元素，对于这些元素，block 的计算结果为 true。

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) [或]

array.fetch(index, default) [或]

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

尝试返回 position index 处的元素。如果 index 超出数组范围，则第一种形式抛出 IndexError 异常，第二种形式返回 default，第三种形式返回调用 block 的值，并将 index 传入其中。index 的负值从数组的末尾开始计数。

array.fill(obj) [或]

array.fill(obj, start [, length]) [或]

array.fill(obj, range) [或]

array.fill { |index| block } [或]

array.fill(start [, length] ) { |index| block } [或]

array.fill(range) { |index| block }

前三种形式将 self 的选定元素设置为 obj。nil 的起始位置等效于零。nil 的长度等效于 self.length。后三种形式使用 block 的值 fill 数组。block 会传递要填充的每个元素的绝对索引。

array.first [或]

array.first(n)

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

array.flatten

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

array.flatten!

就地展平 array。如果未进行任何修改，则返回 nil。（数组不包含任何子数组。）

array.frozen?

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

array.hash

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

array.include?(obj)

如果 obj 出现在 self 中，则返回 true，否则返回 false。

array.index(obj)

返回 self 中第一个与 obj 相等的（==）对象的 index。如果未找到匹配项，则返回 nil。

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

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

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

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

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

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

array.insert(index, obj...)

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

array.inspect

创建 array 的可打印版本。

array.join(sep = $,)

返回一个字符串，该字符串通过将数组的每个元素转换为字符串并用 sep 分隔来创建。

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

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

array.length

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

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

array.collect { |item| block }

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

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

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 }

返回一个新数组，其中包含array中块不为true的项。

array.reject! { |item| block }

删除array中块计算结果为true的元素，但如果未进行任何更改则返回nil。等同于 Array#delete_if。

array.replace(other_array)

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

array.reverse

返回一个新数组，其中包含array的元素，顺序相反。

array.reverse!

就地反转array。

array.reverse_each {|item| block }

与 Array#each 相同，但以相反的顺序遍历array。

array.rindex(obj)

返回array中最后一个与 obj 相等的对象的索引。如果未找到匹配项，则返回nil。

array.select {|item| block }

调用块，将array中的连续元素传递给它，并返回一个数组，其中包含块返回true值的那些元素。

array.shift

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

array.size

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

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

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

array[start, length] [或] array[range]

返回index处的元素，或返回从start开始并继续length个元素的子数组，或返回由range指定的子数组。负索引从数组末尾反向计数（-1 是最后一个元素）。如果index（或起始索引）超出范围，则返回nil。

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

array.slice!(range)

删除由index（可选地带长度）或range给出的元素。返回删除的对象、子数组或nil（如果index超出范围）。

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

返回通过对 self 进行排序创建的新数组。

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

对 self 进行排序。

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, ...) [或]

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

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

@

移动到绝对位置。

A

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

a

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

B

字符串（降序位顺序）。

b

位字符串（升序位顺序）。

C

无符号字符。

c

字符。

D, d

双精度浮点数，本机格式。

E

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

e

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

F, f

单精度浮点数，本机格式。

G

双精度浮点数，网络（大端）字节序。

g

单精度浮点数，网络（大端）字节序。

H

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

h

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

I

无符号整数。

i

整数。

L

无符号长整数。

l

长整数。

M

带引号的可打印字符串，MIME 编码（参见 RFC 2045）。

m

Base64 编码的字符串。

N

长整数，网络（大端）字节序。

n

短整数，网络（大端）字节序。

P

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

p

指向空字符终止字符串的指针。

Q, q

64 位数字。

S

无符号短整数。

s

短整数。

U

UTF-8。

u

UU 编码的字符串。

V

长整数，小端字节序。

v

短整数，小端字节序。

w

BER 压缩整数 \fnm。

X

后退一个字节。

x

空字节。

Z

与 a 相同，但使用 * 添加空字符。