建立一個 Hash 從 XML 就如同 Hash.from_xml，但同時允許 Symbol 和 YAML。

傳回一個包含成對集合的 Hash，其中金鑰為節點名稱，而值為其內容

xml = <<-XML
  <?xml version="1.0" encoding="UTF-8"?>
    <hash>
      <foo type="integer">1</foo>
      <bar type="integer">2</bar>
    </hash>
XML

hash = Hash.from_xml(xml)
# => {"hash"=>{"foo"=>1, "bar"=>2}}

如果 XML 包含具有 type="yaml" 或 type="symbol" 的屬性，則會引發 DisallowedType。使用 Hash.from_trusted_xml 來剖析此 XML。

自訂的 disallowed_types 也能以陣列形式傳遞。

xml = <<-XML
  <?xml version="1.0" encoding="UTF-8"?>
    <hash>
      <foo type="integer">1</foo>
      <bar type="string">"David"</bar>
    </hash>
XML

hash = Hash.from_xml(xml, ['integer'])
# => ActiveSupport::XMLConverter::DisallowedType: Disallowed type attribute: "integer"

請注意，傳遞自訂的不允許類型會覆寫預設類型，也就是 Symbol 和 YAML。

驗證雜湊中的所有金鑰是否與 *valid_keys 相符，如果不相符則引發 ArgumentError。

請注意，金鑰的處理方式與 HashWithIndifferentAccess 不同，這表示字串和符號金鑰不會相符。

{ name: 'Rob', years: '28' }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key: :years. Valid keys are: :name, :age"
{ name: 'Rob', age: '28' }.assert_valid_keys('name', 'age') # => raises "ArgumentError: Unknown key: :name. Valid keys are: 'name', 'age'"
{ name: 'Rob', age: '28' }.assert_valid_keys(:name, :age)   # => passes, raises nothing

從 Hash 中移除所有空白值，並回傳它本身。使用 Object#blank? 來判斷值是否為空白。

h = { a: "", b: 1, c: nil, d: [], e: false, f: true }
h.compact_blank!
# => { b: 1, f: true }

傳回雜湊的深度拷貝。

hash = { a: { b: 'b' } }
dup  = hash.deep_dup
dup[:a][:c] = 'c'

hash[:a][:c] # => nil
dup[:a][:c]  # => "c"

傳回一個新的雜湊，其中 self 和 other_hash 已遞迴合併。

h1 = { a: true, b: { c: [1, 2, 3] } }
h2 = { a: false, b: { x: [3, 4, 5] } }

h1.deep_merge(h2) # => { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }

與標準函式庫中的 Hash#merge 類似，可以提供一個區塊來合併值

h1 = { a: 100, b: 200, c: { c1: 100 } }
h2 = { b: 250, c: { c1: 200 } }
h1.deep_merge(h2) { |key, this_val, other_val| this_val + other_val }
# => { a: 100, b: 450, c: { c1: 300 } }

傳回一個新的雜湊，其中所有鍵都轉換為字串。這包括根雜湊中的鍵，以及所有巢狀雜湊和陣列中的鍵。

hash = { person: { name: 'Rob', age: '28' } }

hash.deep_stringify_keys
# => {"person"=>{"name"=>"Rob", "age"=>"28"}}

破壞性地將所有鍵轉換為字串。這包括根雜湊中的鍵，以及所有巢狀雜湊和陣列中的鍵。

傳回一個新的雜湊，其中所有鍵都轉換為符號，只要它們對應到 to_sym。這包括根雜湊中的鍵，以及所有巢狀雜湊和陣列中的鍵。

hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }

hash.deep_symbolize_keys
# => {:person=>{:name=>"Rob", :age=>"28"}}

破壞性地將所有鍵轉換為符號，只要它們對應到 to_sym。這包括根雜湊中的鍵，以及所有巢狀雜湊和陣列中的鍵。

傳回一個新的雜湊，其中所有鍵都由區塊操作轉換。這包括根雜湊中的鍵，以及所有巢狀雜湊和陣列中的鍵。

hash = { person: { name: 'Rob', age: '28' } }

hash.deep_transform_keys{ |key| key.to_s.upcase }
# => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}

破壞性地將所有鍵使用區塊操作轉換。這包括根雜湊中的鍵，以及所有巢狀雜湊和陣列中的鍵。

傳回一個新的雜湊，其中所有值都已透過區塊運算轉換。這包括根雜湊和所有巢狀雜湊與陣列中的值。

hash = { person: { name: 'Rob', age: '28' } }

hash.deep_transform_values{ |value| value.to_s.upcase }
# => {person: {name: "ROB", age: "28"}}

使用區塊運算，破壞性地轉換所有值。這包括根雜湊和所有巢狀雜湊與陣列中的值。

傳回一個雜湊，其中包含除了給定金鑰以外的所有內容。

hash = { a: true, b: false, c: nil }
hash.except(:c)     # => { a: true, b: false }
hash.except(:a, :b) # => { c: nil }
hash                # => { a: true, b: false, c: nil }

這對於將一組參數限制為除了幾個已知切換以外的所有內容很有用

@person.update(params[:person].except(:admin))

從雜湊中移除給定的金鑰，並傳回雜湊。

hash = { a: true, b: false, c: nil }
hash.except!(:c) # => { a: true, b: false }
hash             # => { a: true, b: false }

移除並傳回與給定金鑰相符的金鑰/值對。

hash = { a: 1, b: 2, c: 3, d: 4 }
hash.extract!(:a, :b) # => {:a=>1, :b=>2}
hash                  # => {:c=>3, :d=>4}

預設情況下，只有 Hash 本身的實例可以提取。 Hash 的子類別可以實作此方法並傳回 true，以宣告自己是可提取的。如果 Hash 可提取，則 Array#extract_options! 會在 Array 的最後一個元素為 Array 時，將其從 Array 中移除。

當物件巢狀在接收 with_indifferent_access 的物件下時呼叫。這個方法會由封裝物件在目前的物件上呼叫，並預設別名為 with_indifferent_access。Hash 的子類別可以覆寫這個方法，如果轉換成 ActiveSupport::HashWithIndifferentAccess 不合適的話，回傳 self。

b = { b: 1 }
{ a: b }.with_indifferent_access['a'] # calls b.nested_under_indifferent_access
# => {"b"=>1}

將呼叫者併入 other_hash。例如，

options = options.reverse_merge(size: 25, velocity: 10)

等同於

options = { size: 25, velocity: 10 }.merge(options)

這對於使用預設值初始化選項雜湊特別有用。

破壞性的 reverse_merge。

只使用指定的鍵值取代雜湊。傳回包含已移除鍵值對的雜湊。

hash = { a: 1, b: 2, c: 3, d: 4 }
hash.slice!(:a, :b)  # => {:c=>3, :d=>4}
hash                 # => {:a=>1, :b=>2}

傳回所有鍵都轉換為字串的新雜湊。

hash = { name: 'Rob', age: '28' }

hash.stringify_keys
# => {"name"=>"Rob", "age"=>"28"}

破壞性地將所有鍵轉換為字串。與 stringify_keys 相同，但會修改 self。

傳回一個新的雜湊，其中所有金鑰都轉換為符號，只要它們對應到 to_sym。

hash = { 'name' => 'Rob', 'age' => '28' }

hash.symbolize_keys
# => {:name=>"Rob", :age=>"28"}

破壞性地將所有金鑰轉換為符號，只要它們對應到 to_sym。與 symbolize_keys 相同，但會修改 self。

傳回一個字串表示，適合用作 URL 查詢字串

{name: 'David', nationality: 'Danish'}.to_query
# => "name=David&nationality=Danish"

可以傳遞一個選用的命名空間來封裝金鑰名稱

{name: 'David', nationality: 'Danish'}.to_query('user')
# => "user%5Bname%5D=David&user%5Bnationality%5D=Danish"

組成查詢字串的字串配對「金鑰=值」會依序以升冪順序進行詞彙排序。

傳回一個字串，其中包含其接收者的 XML 表示

{ foo: 1, bar: 2 }.to_xml
# =>
# <?xml version="1.0" encoding="UTF-8"?>
# <hash>
#   <foo type="integer">1</foo>
#   <bar type="integer">2</bar>
# </hash>

為此，此方法會迴圈處理配對，並根據值建立節點。給定一個配對 金鑰、值

• 如果 值 是雜湊，則會使用 金鑰 作為 :root 進行遞迴呼叫。

• 如果 值 是陣列，則會使用 金鑰 作為 :root，並將 金鑰 單數化作為 :children 進行遞迴呼叫。

• 如果 值 是可呼叫物件，則它必須預期一個或兩個參數。根據元數，可呼叫物件會以 options 雜湊作為第一個參數，使用 金鑰 作為 :root，並將 金鑰 單數化作為第二個參數來呼叫。可呼叫物件可以使用 options[:builder] 來新增節點。

  {foo: lambda { |options, key| options[:builder].b(key) }}.to_xml
  # => "<b>foo</b>"
  

• 如果 value 回應 to_xml，則會呼叫方法，並將 key 作為 :root。

  class Foo
    def to_xml(options)
      options[:builder].bar 'fooing!'
    end
  end
  
  { foo: Foo.new }.to_xml(skip_instruct: true)
  # =>
  # <hash>
  #   <bar>fooing!</bar>
  # </hash>
  

• 否則，會建立一個標籤為 key 的節點，並將 value 的字串表示形式作為文字節點。如果 value 為 nil，則會新增一個屬性「nil」，並設定為「true」。除非選項 :skip_types 存在且為 true，否則也會根據下列對應新增一個屬性「type」

  XML_TYPE_NAMES = {
    "Symbol"     => "symbol",
    "Integer"    => "integer",
    "BigDecimal" => "decimal",
    "Float"      => "float",
    "TrueClass"  => "boolean",
    "FalseClass" => "boolean",
    "Date"       => "date",
    "DateTime"   => "dateTime",
    "Time"       => "dateTime"
  }
  

預設根節點為「hash」，但這可透過 :root 選項進行設定。

預設 XML 建構器為 Builder::XmlMarkup 的新實例。你可以使用 :builder 選項設定自己的建構器。此方法也接受 :dasherize 等選項，這些選項會轉送給建構器。

從接收器中傳回 ActiveSupport::HashWithIndifferentAccess

{ a: 1 }.with_indifferent_access['a'] # => 1