类 Array

数组是一个有序的、整数索引的、称为元素的对象集合。任何对象（甚至是另一个数组）都可以是数组元素，数组可以包含不同类型的对象。

数组索引¶ ↑

数组索引从 0 开始，就像 C 或 Java 一样。

正索引是从第一个元素开始的偏移量

索引 0 表示第一个元素。
索引 1 表示第二个元素。
…

负索引是从数组末尾开始的偏移量

索引 -1 表示最后一个元素。
索引 -2 表示倒数第二个元素。
…

非负索引在范围内当且仅当它小于数组的大小。对于一个 3 元素数组

索引 0 到 2 在范围内。
索引 3 超出范围。

负索引在范围内当且仅当它的绝对值不大于数组的大小。对于一个 3 元素数组

索引 -1 到 -3 在范围内。
索引 -4 超出范围。

虽然数组中的有效索引始终是整数，但某些方法（在类 Array 内部和外部）都接受一个或多个非整数参数，这些参数是可转换为整数的对象。

创建数组¶ ↑

您可以使用以下方法显式创建 Array 对象

数组字面量
```
[1, 'one', :one, [2, 'two', :two]]
```

数组字面量

%w[foo bar baz] # => ["foo", "bar", "baz"]
%w[1 % *]       # => ["1", "%", "*"]

数组字面量

%i[foo bar baz] # => [:foo, :bar, :baz]
%i[1 % *]       # => [:"1", :%, :*]

方法 Kernel#Array

Array(["a", "b"])             # => ["a", "b"]
Array(1..5)                   # => [1, 2, 3, 4, 5]
Array(key: :value)            # => [[:key, :value]]
Array(nil)                    # => []
Array(1)                      # => [1]
Array({:a => "a", :b => "b"}) # => [[:a, "a"], [:b, "b"]]

方法 Array.new
```
Array.new               # => []
Array.new(3)            # => [nil, nil, nil]
Array.new(4) {Hash.new} # => [{}, {}, {}, {}]
Array.new(3, true)      # => [true, true, true]
```
请注意，上面的最后一个示例使用对同一个对象的引用来填充数组。这仅在该对象是本机不可变对象（如符号、数字、nil、true 或 false）时才推荐。

另一种使用块创建包含各种对象的数组的方法；这种用法对于可变对象（如哈希、字符串或其他数组）是安全的
```
Array.new(4) {|i| i.to_s } # => ["0", "1", "2", "3"]
```
以下是如何创建多维数组的方法
```
Array.new(3) {Array.new(3)}
# => [[nil, nil, nil], [nil, nil, nil], [nil, nil, nil]]
```

许多 Ruby 方法（在核心和标准库中）都提供实例方法 to_a，该方法将对象转换为数组。

ARGF#to_a
Array#to_a
Enumerable#to_a
Hash#to_a
MatchData#to_a
NilClass#to_a
OptionParser#to_a
Range#to_a
Set#to_a
Struct#to_a
Time#to_a
Benchmark::Tms#to_a
CSV::Table#to_a
Enumerator::Lazy#to_a
Gem::List#to_a
Gem::NameTuple#to_a
Gem::Platform#to_a
Gem::RequestSet::Lockfile::Tokenizer#to_a
Gem::SourceList#to_a
OpenSSL::X509::Extension#to_a
OpenSSL::X509::Name#to_a
Racc::ISet#to_a
Rinda::RingFinger#to_a
Ripper::Lexer::Elem#to_a
RubyVM::InstructionSequence#to_a
YAML::DBM#to_a

示例用法¶ ↑

除了通过 Enumerable 模块混合进来的方法之外，Array 类还拥有用于访问、搜索和操作数组的专有方法。

下面将说明一些比较常用的方法。

访问元素¶ ↑

可以使用 Array#[] 方法检索数组中的元素。它可以接受一个整数参数（数字索引）、一对参数（起始位置和长度）或一个范围。负索引从末尾开始计数，-1 代表最后一个元素。

arr = [1, 2, 3, 4, 5, 6]
arr[2]    #=> 3
arr[100]  #=> nil
arr[-3]   #=> 4
arr[2, 3] #=> [3, 4, 5]
arr[1..4] #=> [2, 3, 4, 5]
arr[1..-3] #=> [2, 3, 4]

另一种访问特定数组元素的方法是使用 at 方法

arr.at(0) #=> 1

slice 方法的工作方式与 Array#[] 相同。

要对超出数组边界的索引引发错误，或者在发生这种情况时提供默认值，可以使用 fetch。

arr = ['a', 'b', 'c', 'd', 'e', 'f']
arr.fetch(100) #=> IndexError: index 100 outside of array bounds: -6...6
arr.fetch(100, "oops") #=> "oops"

特殊方法 first 和 last 分别返回数组的第一个和最后一个元素。

arr.first #=> 1
arr.last  #=> 6

要返回数组的前 n 个元素，请使用 take

arr.take(3) #=> [1, 2, 3]

drop 与 take 相反，它返回删除前 n 个元素后的元素

arr.drop(3) #=> [4, 5, 6]

获取有关数组的信息¶ ↑

数组始终跟踪其自身的长度。要查询数组中包含的元素数量，请使用 length、count 或 size。

browsers = ['Chrome', 'Firefox', 'Safari', 'Opera', 'IE']
browsers.length #=> 5
browsers.count #=> 5

要检查数组是否包含任何元素

browsers.empty? #=> false

要检查数组中是否包含特定项目

browsers.include?('Konqueror') #=> false

向数组添加项目¶ ↑

可以使用 push 或 << 将项目添加到数组的末尾。

arr = [1, 2, 3, 4]
arr.push(5) #=> [1, 2, 3, 4, 5]
arr << 6    #=> [1, 2, 3, 4, 5, 6]

unshift 将在数组的开头添加一个新项目。

arr.unshift(0) #=> [0, 1, 2, 3, 4, 5, 6]

使用 insert，您可以在数组中的任何位置添加一个新元素。

arr.insert(3, 'apple')  #=> [0, 1, 2, 'apple', 3, 4, 5, 6]

使用 insert 方法，您还可以一次插入多个值。

arr.insert(3, 'orange', 'pear', 'grapefruit')
#=> [0, 1, 2, "orange", "pear", "grapefruit", "apple", 3, 4, 5, 6]

从数组中删除项目¶ ↑

方法 pop 删除数组中的最后一个元素并将其返回。

arr =  [1, 2, 3, 4, 5, 6]
arr.pop #=> 6
arr #=> [1, 2, 3, 4, 5]

要检索并同时删除第一个项目，请使用 shift

arr.shift #=> 1
arr #=> [2, 3, 4, 5]

要删除特定索引处的元素

arr.delete_at(2) #=> 4
arr #=> [2, 3, 5]

要删除数组中任何位置的特定元素，请使用 delete

arr = [1, 2, 2, 3]
arr.delete(2) #=> 2
arr #=> [1,3]

如果您需要从数组中删除 nil 值，则 compact 是一个有用的方法。

arr = ['foo', 0, nil, 'bar', 7, 'baz', nil]
arr.compact  #=> ['foo', 0, 'bar', 7, 'baz']
arr          #=> ['foo', 0, nil, 'bar', 7, 'baz', nil]
arr.compact! #=> ['foo', 0, 'bar', 7, 'baz']
arr          #=> ['foo', 0, 'bar', 7, 'baz']

另一个常见需求是从数组中删除重复元素。

它具有非破坏性方法 uniq 和破坏性方法 uniq!

arr = [2, 5, 6, 556, 6, 6, 8, 9, 0, 123, 556]
arr.uniq #=> [2, 5, 6, 556, 8, 9, 0, 123]

遍历数组¶ ↑

与包含 Enumerable 模块的所有类一样，Array 也有一个 each 方法，它定义了应该遍历哪些元素以及如何遍历。在 Array 的 each 情况下，Array 实例中的所有元素都将按顺序传递给提供的块。

请注意，此操作不会更改数组。

arr = [1, 2, 3, 4, 5]
arr.each {|a| print a -= 10, " "}
# prints: -9 -8 -7 -6 -5
#=> [1, 2, 3, 4, 5]

另一个有时有用的迭代器是 reverse_each，它将以相反的顺序遍历数组中的元素。

words = %w[first second third fourth fifth sixth]
str = ""
words.reverse_each {|word| str += "#{word} "}
p str #=> "sixth fifth fourth third second first "

可以使用 map 方法根据原始数组创建一个新数组，但值将由提供的块修改。

arr.map {|a| 2*a}     #=> [2, 4, 6, 8, 10]
arr                   #=> [1, 2, 3, 4, 5]
arr.map! {|a| a**2}   #=> [1, 4, 9, 16, 25]
arr                   #=> [1, 4, 9, 16, 25]

从数组中选择项目¶ ↑

可以根据块中定义的条件从数组中选择元素。选择可以以破坏性或非破坏性的方式进行。虽然破坏性操作会修改它们调用的数组，但非破坏性方法通常会返回一个包含所选元素的新数组，但不会改变原始数组。

非破坏性选择¶ ↑

arr = [1, 2, 3, 4, 5, 6]
arr.select {|a| a > 3}       #=> [4, 5, 6]
arr.reject {|a| a < 3}       #=> [3, 4, 5, 6]
arr.drop_while {|a| a < 4}   #=> [4, 5, 6]
arr                          #=> [1, 2, 3, 4, 5, 6]

破坏性选择¶ ↑

select! 和 reject! 是 select 和 reject 的对应破坏性方法。

类似于 select 与 reject，delete_if 和 keep_if 在提供相同块时具有完全相反的结果。

arr.delete_if {|a| a < 4}   #=> [4, 5, 6]
arr                         #=> [4, 5, 6]

arr = [1, 2, 3, 4, 5, 6]
arr.keep_if {|a| a < 4}   #=> [1, 2, 3]
arr                       #=> [1, 2, 3]

这里有什么¶ ↑

首先，其他地方有什么。类数组

继承自类对象。
包含模块 Enumerable，它提供了数十种附加方法。

这里，类数组提供了对以下内容有用的方法：

创建数组的方法¶ ↑

::[]：返回一个用给定对象填充的新数组。
::new：返回一个新数组。
::try_convert：返回一个由给定对象创建的新数组。

查询方法¶ ↑

length，size：返回元素的数量。
include?：返回任何元素是否==给定对象。
empty?: 返回数组是否为空。
all?: 返回数组中所有元素是否满足给定条件。
any?: 返回数组中是否存在满足给定条件的元素。
none?: 返回数组中是否没有元素与给定对象相等。
one?: 返回数组中是否只有一个元素与给定对象相等。
count: 返回满足给定条件的元素数量。
find_index, index: 返回第一个满足给定条件的元素的索引。
rindex: 返回最后一个满足给定条件的元素的索引。
hash: 返回数组的整数哈希值。

比较方法¶ ↑

#<=>: 返回 -1、0 或 1，分别表示 self 小于、等于或大于给定对象。
==: 返回 self 中的每个元素是否与给定对象中的对应元素相等。
eql?: 返回 self 中的每个元素是否与给定对象中的对应元素相等。

获取方法¶ ↑

这些方法不会修改 self。

[]: 返回一个或多个元素。
fetch: 返回给定偏移处的元素。
first: 返回一个或多个前导元素。
last: 返回一个或多个尾随元素。
max: 返回一个或多个最大值元素，由 <=> 或给定块决定。
min: 返回一个或多个最小值元素，由 <=> 或给定块决定。
minmax: 返回最小值元素和最大值元素，由 <=> 或给定块决定。
assoc: 返回第一个元素，该元素是一个数组，其第一个元素与给定对象相等。
rassoc: 返回第一个元素，该元素是一个数组，其第二个元素与给定对象相等。
at: 返回给定偏移处的元素。
values_at: 返回给定偏移处的元素。
dig: 返回嵌套对象中由给定索引和附加参数指定的元素。
drop: 返回根据给定索引确定的尾部元素。
take: 返回根据给定索引确定的头部元素。
drop_while: 返回根据给定代码块确定的尾部元素。
take_while: 返回根据给定代码块确定的头部元素。
slice: 返回根据给定参数确定的连续元素。
sort: 返回根据<=>或给定代码块确定的顺序排列的所有元素。
reverse: 返回所有元素的逆序排列。
compact: 返回一个包含所有非nil元素的数组。
select, filter: 返回一个包含根据给定代码块选择的元素的数组。
uniq: 返回一个包含非重复元素的数组。
rotate: 返回所有元素，其中一些元素从一端旋转到另一端。
bsearch: 返回通过二分搜索选择的元素，该元素由给定代码块确定。
bsearch_index: 返回通过二分搜索选择的元素的索引，该元素由给定代码块确定。
sample: 返回一个或多个随机元素。
shuffle: 返回以随机顺序排列的元素。

分配方法¶ ↑

这些方法在self中添加、替换或重新排序元素。

[]=: 使用给定对象分配指定元素。
push, append, <<: 追加尾部元素。
unshift, prepend: 预置头部元素。
insert: 在给定偏移量处插入给定对象；不替换元素。
concat: 将给定数组中的所有元素追加到当前数组。
fill: 用指定的对象替换指定元素。
replace: 用给定数组的内容替换当前数组的内容。
reverse!: 将当前数组替换为其元素反转后的数组。
rotate!: 将当前数组替换为其元素旋转后的数组。
shuffle!: 将当前数组替换为其元素随机排序后的数组。
sort!: 将当前数组替换为其元素排序后的数组，排序方式由 <=> 或给定的代码块决定。
sort_by!: 将当前数组替换为其元素排序后的数组，排序方式由给定的代码块决定。

删除方法¶ ↑

这些方法都从当前数组中删除元素。

pop: 删除并返回最后一个元素。
shift: 删除并返回第一个元素。
compact!: 删除所有 nil 元素。
delete: 删除与给定对象相等的元素。
delete_at: 删除给定偏移处的元素。
delete_if: 删除由给定代码块指定的元素。
keep_if: 删除由给定代码块未指定的元素。
reject!: 删除由给定代码块指定的元素。
select!, filter!: 删除由给定代码块未指定的元素。
slice!: 删除并返回一系列元素。
uniq!: 删除重复项。

组合方法¶ ↑

#&: 返回一个数组，其中包含当前数组和给定数组中都存在的元素。
intersection: 返回一个数组，其中包含当前数组和每个给定数组中都存在的元素。
+: 返回一个数组，其中包含当前数组的所有元素，后面跟着给定数组的所有元素。
-: 返回一个数组，其中包含当前数组中所有不在给定数组中的元素。
#|: 返回一个数组，其中包含当前数组的所有元素和给定数组的所有元素，删除重复项。
union: 返回一个数组，其中包含当前数组的所有元素和所有给定数组的所有元素，删除重复项。
difference: 返回一个数组，其中包含当前数组中所有不在任何给定数组中的元素。
product: 返回或生成来自 self 和给定数组的所有元素组合。

迭代方法¶ ↑

each: 将每个元素传递给给定的代码块。
reverse_each: 将每个元素（以相反顺序）传递给给定的代码块。
each_index: 将每个元素索引传递给给定的代码块。
cycle: 使用每个元素调用给定的代码块，然后再次执行，持续指定的次数或永远执行。
combination: 使用 self 的元素组合调用给定的代码块；组合不会重复使用相同的元素。
permutation: 使用 self 的元素排列调用给定的代码块；排列不会重复使用相同的元素。
repeated_combination: 使用 self 的元素组合调用给定的代码块；组合可以重复使用相同的元素。
repeated_permutation: 使用 self 的元素排列调用给定的代码块；排列可以重复使用相同的元素。

转换方法¶ ↑

map, collect: 返回一个数组，其中包含每个元素的代码块返回值。
map!, collect!: 用代码块返回值替换每个元素。
flatten: 返回一个数组，它是 self 的递归扁平化结果。
flatten!: 用来自该数组的元素替换 self 中的每个嵌套数组。
inspect, to_s: 返回一个新的 String，其中包含元素。
join: 返回一个新的 String，其中包含由字段分隔符连接的元素。
to_a: 返回 self 或包含所有元素的新数组。
to_ary: 返回 self。
to_h: 返回由元素形成的新哈希。
transpose: 转置 self，它必须是数组的数组。
zip: 返回包含 self 和给定数组的新数组；有关详细信息，请参阅链接。

其他方法¶ ↑

*: 返回以下之一
- 对于整数参数 n，返回一个新数组，该数组是 self 的 n 个副本的串联。
- 对于字符串参数 field_separator，返回一个新字符串，该字符串等效于 join(field_separator)。
abbrev: 返回元素的非歧义缩写的哈希。
pack: 将元素打包成二进制序列。
sum: 返回元素的总和，根据 + 或给定的代码块。

公共类方法

[](*args) 点击切换源代码

返回一个用给定对象填充的新数组。

Array.[]( 1, 'a', /^A/)  # => [1, "a", /^A/]
Array[ 1, 'a', /^A/ ]    # => [1, "a", /^A/]
[ 1, 'a', /^A/ ]         # => [1, "a", /^A/]

static VALUE
rb_ary_s_create(int argc, VALUE *argv, VALUE klass)
{
    VALUE ary = ary_new(klass, argc);
    if (argc > 0 && argv) {
        ary_memcpy(ary, 0, argc, argv);
        ARY_SET_LEN(ary, argc);
    }

    return ary;
}

new → new_empty_array 点击切换源代码

new(array) → new_array

new(size) → new_array

new(size, default_value) → new_array

new(size) {|index| ... } → new_array

返回一个新的 Array。

没有代码块和参数，返回一个新的空 Array 对象。

没有代码块和单个 Array 参数 array，返回一个由 array 形成的新 Array。

a = Array.new([:foo, 'bar', 2])
a.class # => Array
a # => [:foo, "bar", 2]

没有代码块和单个 Integer 参数 size，返回一个给定大小的新 Array，其元素均为 nil。

a = Array.new(3)
a # => [nil, nil, nil]

没有代码块和参数 size 和 default_value，返回一个给定大小的 Array；每个元素都是相同的 default_value。

a = Array.new(3, 'x')
a # => ['x', 'x', 'x']

带有代码块和参数 size，返回一个给定大小的 Array；代码块使用每个连续的整数 index 调用；该 index 的元素是代码块的返回值。

a = Array.new(3) {|index| "Element #{index}" }
a # => ["Element 0", "Element 1", "Element 2"]

如果 size 为负数，则引发 ArgumentError。

带有代码块和没有参数，或单个参数 0，忽略代码块并返回一个新的空 Array。

static VALUE
rb_ary_initialize(int argc, VALUE *argv, VALUE ary)
{
    long len;
    VALUE size, val;

    rb_ary_modify(ary);
    if (argc == 0) {
        rb_ary_reset(ary);
        assert(ARY_EMBED_P(ary));
        assert(ARY_EMBED_LEN(ary) == 0);
        if (rb_block_given_p()) {
            rb_warning("given block not used");
        }
        return ary;
    }
    rb_scan_args(argc, argv, "02", &size, &val);
    if (argc == 1 && !FIXNUM_P(size)) {
        val = rb_check_array_type(size);
        if (!NIL_P(val)) {
            rb_ary_replace(ary, val);
            return ary;
        }
    }

    len = NUM2LONG(size);
    /* NUM2LONG() may call size.to_int, ary can be frozen, modified, etc */
    if (len < 0) {
        rb_raise(rb_eArgError, "negative array size");
    }
    if (len > ARY_MAX_SIZE) {
        rb_raise(rb_eArgError, "array size too big");
    }
    /* recheck after argument conversion */
    rb_ary_modify(ary);
    ary_resize_capa(ary, len);
    if (rb_block_given_p()) {
        long i;

        if (argc == 2) {
            rb_warn("block supersedes default value argument");
        }
        for (i=0; i<len; i++) {
            rb_ary_store(ary, i, rb_yield(LONG2NUM(i)));
            ARY_SET_LEN(ary, i + 1);
        }
    }
    else {
        ary_memfill(ary, 0, len, val);
        ARY_SET_LEN(ary, len);
    }
    return ary;
}

try_convert(object) → object, new_array, 或 nil 点击切换源代码

如果 object 是一个 Array 对象，则返回 object。

否则，如果 object 响应 :to_ary，则调用 object.to_ary 并返回结果。

如果 object 不响应 :to_ary，则返回 nil。

除非 object.to_ary 返回一个 Array 对象，否则会抛出异常。

static VALUE
rb_ary_s_try_convert(VALUE dummy, VALUE ary)
{
    return rb_check_array_type(ary);
}

公共实例方法

array & other_array → new_array 点击切换源代码

返回一个新的 Array，其中包含 array 和 Array other_array 中找到的每个元素；重复项被省略；使用 eql? 比较项目（项目还必须正确实现 hash）。

[0, 1, 2, 3] & [1, 2] # => [1, 2]
[0, 1, 0, 1] & [0, 1] # => [0, 1]

保留来自 array 的顺序。

[0, 1, 2] & [3, 2, 1, 0] # => [0, 1, 2]