从 XML 构建一个 Hash，就像 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             # => { 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 中弹出。

当对象嵌套在接收 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"

构成查询字符串的字符串对“key=value”按字母顺序按升序排序。

返回包含接收者 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>

为此，该方法遍历对并构建取决于值的节点。给定一对 key、value

• 如果 value 是一个哈希，则使用 key 作为 :root 进行递归调用。

• 如果 value 是一个数组，则使用 key 作为 :root，并使用 key 的单数形式作为 :children 进行递归调用。

• 如果 value 是一个可调用对象，则它必须接受一个或两个参数。根据元数，可调用对象将使用 options 哈希作为第一个参数调用，使用 key 作为 :root，并将 key 的单数形式作为第二个参数调用。可调用对象可以使用 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 选项且为真，否则还将根据以下映射添加“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