类 Array

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，它将对象转换为数组。

示例用法¶ ↑

除了通过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]

此处内容¶ ↑

首先，其他内容。类 Array

继承自类 Object。
包含模块 Enumerable，它提供了数十种其他方法。

此处，类 Array 提供了对以下内容有用的方法

用于创建数组的方法¶ ↑

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

用于查询的方法¶ ↑

length、size：返回元素计数。
include?：返回任何元素是否 == 给定对象。
empty?：返回是否没有元素。
all?：返回是否所有元素都满足给定的条件。
any?：返回是否有任何元素满足给定的条件。
none?：返回是否没有元素 == 给定的对象。
one?：返回是否恰好有一个元素 == 给定的对象。
count：返回满足给定条件的元素数量。
find_index、index：返回满足给定条件的第一个元素的索引。
rindex：返回满足给定条件的最后一个元素的索引。
hash：返回整数哈希码。

比较方法¶ ↑

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

获取方法¶ ↑

这些方法不修改 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：用给定数组的内容替换 self 的内容。
reverse!：用其元素反转后的内容替换 self。
rotate!：用其元素旋转后的内容替换 self。
shuffle!：用其元素随机排序后的内容替换 self。
sort!：用根据 <=> 或给定块排序后的元素替换 self。
sort_by!：用根据给定块排序后的元素替换 self。

删除方法¶ ↑

这些方法都会从 self 中删除元素

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

组合方法¶ ↑

&：返回一个包含在 self 和给定数组中同时找到的元素的数组。
intersection：返回一个包含在 self 和每个给定数组中同时找到的元素的数组。
+：返回一个包含 self 的所有元素和给定数组的所有元素的数组。
-：返回一个包含 self 的所有元素的数组，这些元素未在给定数组中找到。
|：返回一个包含 self 的所有元素和给定数组的所有元素的数组，已删除重复项。
union：返回一个包含 self 的所有元素和给定数组的所有元素的数组，已删除重复项。
difference：返回一个包含 self 的所有元素的数组，这些元素未在任何给定数组中找到。
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：返回一个新字符串，其中元素由字段分隔符连接。
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形成的新数组

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

如果没有块和单个Integer参数size，则返回一个给定大小的新数组，其元素全部为nil

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

如果没有块和参数size和default_value，则返回一个给定大小的数组；每个元素都是相同的default_value

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

使用块和参数size，返回给定大小的数组；使用每个连续整数index调用该块；该index的元素是块的返回值

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

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

使用块且没有参数，或单个参数0，则忽略该块并返回一个新的空数组。

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 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]