将它的参数包装在一个数组中，除非它已经是一个数组（或类似数组）。

具体而言

• 如果参数是nil，则返回一个空数组。

• 否则，如果参数响应to_ary，则调用它，并返回其结果。

• 否则，返回一个带有参数作为其单个元素的数组。

  Array.wrap(nil)       # => []
  Array.wrap([1, 2, 3]) # => [1, 2, 3]
  Array.wrap(0)         # => [0]
  

此方法的用途类似于Kernel#Array，但存在一些差异

• 如果参数响应to_ary，则调用该方法。Kernel#Array 如果返回值是nil，则继续尝试to_a，但Array.wrap立即返回一个带有参数作为其单个元素的数组。

• 如果to_ary的返回值既不是nil也不是Array对象，Kernel#Array会抛出一个异常，而Array.wrap不会，它只是返回该值。

• 它不会在参数上调用to_a，如果参数不响应to_ary，它会返回一个带有参数作为其单个元素的数组。

最后一点用一些枚举来解释

Array(foo: :bar)      # => [[:foo, :bar]]
Array.wrap(foo: :bar) # => [{:foo=>:bar}]

还有一个相关的习惯用法，它使用展开运算符

[*object]

对于nil返回[]，但在其他情况下调用Array(object)。

上面解释的与Kernel#Array的差异适用于object的其余部分。

返回数组的深层副本。

array = [1, [2, 3]]
dup   = array.deep_dup
dup[1][2] = 4

array[1][2] # => nil
dup[1][2]   # => 4

返回一个Array的副本，不包括指定的元素。

["David", "Rafael", "Aaron", "Todd"].excluding("Aaron", "Todd") # => ["David", "Rafael"]
[ [ 0, 1 ], [ 1, 0 ] ].excluding([ [ 1, 0 ] ]) # => [ [ 0, 1 ] ]

注意：这是一种对Enumerable#excluding的优化，它使用Array#-而不是Array#reject，以提高性能。

删除并返回块返回真值的元素。如果没有给出块，则返回一个枚举器。

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
odd_numbers = numbers.extract! { |number| number.odd? } # => [1, 3, 5, 7, 9]
numbers # => [0, 2, 4, 6, 8]

从一组参数中提取选项。如果数组的最后一个元素是哈希，则将其删除并返回，否则返回一个空哈希。

def options(*args)
  args.extract_options!
end

options(1, 2)        # => {}
options(1, 2, a: :b) # => {:a=>:b}

等于self[4]。

%w( a b c d e ).fifth # => "e"

等于self[41]。也被称为访问“reddit”。

(1..42).to_a.forty_two # => 42

等于self[3]。

%w( a b c d e ).fourth # => "d"

返回从position开始的数组尾部。

%w( a b c d ).from(0)  # => ["a", "b", "c", "d"]
%w( a b c d ).from(2)  # => ["c", "d"]
%w( a b c d ).from(10) # => []
%w().from(0)           # => []
%w( a b c d ).from(-2) # => ["c", "d"]
%w( a b c ).from(-10)  # => []

将数组分成number个组，并用fill_with填充任何剩余的插槽，除非它是false。

%w(1 2 3 4 5 6 7 8 9 10).in_groups(3) {|group| p group}
["1", "2", "3", "4"]
["5", "6", "7", nil]
["8", "9", "10", nil]

%w(1 2 3 4 5 6 7 8 9 10).in_groups(3, ' ') {|group| p group}
["1", "2", "3", "4"]
["5", "6", "7", " "]
["8", "9", "10", " "]

%w(1 2 3 4 5 6 7).in_groups(3, false) {|group| p group}
["1", "2", "3"]
["4", "5"]
["6", "7"]

将数组分成大小为number的组，并用fill_with填充任何剩余的插槽，除非它是false。

%w(1 2 3 4 5 6 7 8 9 10).in_groups_of(3) {|group| p group}
["1", "2", "3"]
["4", "5", "6"]
["7", "8", "9"]
["10", nil, nil]

%w(1 2 3 4 5).in_groups_of(2, ' ') {|group| p group}
["1", "2"]
["3", "4"]
["5", " "]

%w(1 2 3 4 5).in_groups_of(2, false) {|group| p group}
["1", "2"]
["3", "4"]
["5"]

返回一个包含传递元素的新数组。

[ 1, 2, 3 ].including(4, 5) # => [ 1, 2, 3, 4, 5 ]
[ [ 0, 1 ] ].including([ [ 1, 0 ] ]) # => [ [ 0, 1 ], [ 1, 0 ] ]

将数组包装在一个ActiveSupport::ArrayInquirer对象中，这提供了一种更友好的方法来检查其类似字符串的内容。

pets = [:cat, :dog].inquiry

pets.cat?     # => true
pets.ferret?  # => false

pets.any?(:cat, :ferret)  # => true
pets.any?(:ferret, :alligator)  # => false

等于self[1]。

%w( a b c d e ).second # => "b"

等于self[-2]。

%w( a b c d e ).second_to_last # => "d"

根据分隔value或可选块的结果，将数组分成一个或多个子数组。

[1, 2, 3, 4, 5].split(3)              # => [[1, 2], [4, 5]]
(1..10).to_a.split { |i| i % 3 == 0 } # => [[1, 2], [4, 5], [7, 8], [10]]

等于self[2]。

%w( a b c d e ).third # => "c"

等于self[-3]。

%w( a b c d e ).third_to_last # => "c"

返回从数组开头到position的部分。

%w( a b c d ).to(0)  # => ["a"]
%w( a b c d ).to(2)  # => ["a", "b", "c"]
%w( a b c d ).to(10) # => ["a", "b", "c", "d"]
%w().to(0)           # => []
%w( a b c d ).to(-2) # => ["a", "b", "c"]
%w( a b c ).to(-10)  # => []

扩展Array#to_s，如果给定:db参数作为格式，则将一组元素转换为逗号分隔的 ID 列表。

此方法的别名为to_formatted_s。

Blog.all.to_fs(:db)  # => "1,2,3"
Blog.none.to_fs(:db) # => "null"
[1,2].to_fs          # => "[1, 2]"

在所有元素上调用to_param，并将结果用斜线连接起来。这在 Action Pack 中由url_for使用。

将数组转换为适合用作 URL 查询字符串的字符串，使用给定的key作为参数名称。

['Rails', 'coding'].to_query('hobbies') # => "hobbies%5B%5D=Rails&hobbies%5B%5D=coding"

将数组转换为逗号分隔的句子，其中最后一个元素由连接词连接。

您可以传递以下选项以更改默认行为。如果您传递一个不在下面列表中的选项键，它将引发ArgumentError。

选项

• :words_connector - 用于连接三个或更多元素的数组中除最后一个元素之外的所有元素的符号或单词（默认值：“， ”）。

• :last_word_connector - 用于连接三个或更多元素的数组中最后一个元素的符号或单词（默认值：“，和 ”）。

• :two_words_connector - 用于连接两个元素数组中元素的符号或单词（默认值：“和 ”）。

• :locale - 如果i18n可用，您可以设置一个语言环境并使用在相应词典文件中定义的“support.array”命名空间中的连接器选项。

示例

[].to_sentence                      # => ""
['one'].to_sentence                 # => "one"
['one', 'two'].to_sentence          # => "one and two"
['one', 'two', 'three'].to_sentence # => "one, two, and three"

['one', 'two'].to_sentence(passing: 'invalid option')
# => ArgumentError: Unknown key: :passing. Valid keys are: :words_connector, :two_words_connector, :last_word_connector, :locale

['one', 'two'].to_sentence(two_words_connector: '-')
# => "one-two"

['one', 'two', 'three'].to_sentence(words_connector: ' or ', last_word_connector: ' or at least ')
# => "one or two or at least three"

使用 :locale 选项

# Given this locale dictionary:
#
#   es:
#     support:
#       array:
#         words_connector: " o "
#         two_words_connector: " y "
#         last_word_connector: " o al menos "

['uno', 'dos'].to_sentence(locale: :es)
# => "uno y dos"

['uno', 'dos', 'tres'].to_sentence(locale: :es)
# => "uno o dos o al menos tres"

通过对每个元素调用 to_xml，返回一个表示数组的 XML 字符串。Active Record 集合委托此方法来表示它们的 XML。

所有元素都应响应 to_xml，如果任何元素没有响应，则会引发异常。

根节点反映第一个元素的类名，如果所有元素都属于同一类型且该类型不是 Hash，则该类名应为复数形式

customer.projects.to_xml

<?xml version="1.0" encoding="UTF-8"?>
<projects type="array">
  <project>
    <amount type="decimal">20000.0</amount>
    <customer-id type="integer">1567</customer-id>
    <deal-date type="date">2008-04-09</deal-date>
    ...
  </project>
  <project>
    <amount type="decimal">57230.0</amount>
    <customer-id type="integer">1567</customer-id>
    <deal-date type="date">2008-04-15</deal-date>
    ...
  </project>
</projects>

否则，根元素为“objects”

[{ foo: 1, bar: 2}, { baz: 3}].to_xml

<?xml version="1.0" encoding="UTF-8"?>
<objects type="array">
  <object>
    <bar type="integer">2</bar>
    <foo type="integer">1</foo>
  </object>
  <object>
    <baz type="integer">3</baz>
  </object>
</objects>

如果集合为空，则默认情况下根元素为“nil-classes”

[].to_xml

<?xml version="1.0" encoding="UTF-8"?>
<nil-classes type="array"/>

要确保有意义的根元素，请使用 :root 选项

customer_with_no_projects.projects.to_xml(root: 'projects')

<?xml version="1.0" encoding="UTF-8"?>
<projects type="array"/>

默认情况下，根节点子节点的节点名称为 root.singularize。你可以使用 :children 选项更改它。

options 哈希被传递到下层

Message.all.to_xml(skip_types: true)

<?xml version="1.0" encoding="UTF-8"?>
<messages>
  <message>
    <created-at>2008-03-07T09:58:18+01:00</created-at>
    <id>1</id>
    <name>1</name>
    <updated-at>2008-03-07T09:58:18+01:00</updated-at>
    <user-id>1</user-id>
  </message>
</messages>