將其參數包在陣列中，除非它已經是陣列（或類似陣列）。

具體來說

• 如果參數為 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_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 以提升效能。

移除並傳回區塊傳回 true 值的元素。如果未提供區塊，則傳回 Enumerator。

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 將元素集合轉換為逗號分隔的 ID 清單，如果給定 :db 參數作為格式。

此方法別名為 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 hash 會向下傳遞。

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>