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

具体来说

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

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

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

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

此方法在目的上类似于 Kernel#Array，但有一些区别

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

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

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

最后一点很容易用一些枚举解释

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，否则用 fill_with 填充任何剩余的槽位。

%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，否则用 fill_with 填充任何剩余的槽位。

%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 - 用于连接数组中最后一个元素的符号或单词（默认值：“, and ”）。

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

• :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>