Hash.html

---
title: Hash
layout: default
---
<div class="main">
    <div class="banner">
        
            <span>Ruby on Rails 8.0.0</span><br />
        
        <div class="type">Class</div>
        <h1>
            Hash
            
                <span class="parent">&lt;
                    
                    <a href="Object.html">Object</a>
                    
                </span>
            
        </h1>
        <ul class="files">
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/array/extract_options_rb.html">activesupport/lib/active_support/core_ext/array/extract_options.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/enumerable_rb.html">activesupport/lib/active_support/core_ext/enumerable.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/hash/conversions_rb.html">activesupport/lib/active_support/core_ext/hash/conversions.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/hash/deep_merge_rb.html">activesupport/lib/active_support/core_ext/hash/deep_merge.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/hash/deep_transform_values_rb.html">activesupport/lib/active_support/core_ext/hash/deep_transform_values.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/hash/except_rb.html">activesupport/lib/active_support/core_ext/hash/except.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/hash/indifferent_access_rb.html">activesupport/lib/active_support/core_ext/hash/indifferent_access.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/hash/keys_rb.html">activesupport/lib/active_support/core_ext/hash/keys.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/hash/reverse_merge_rb.html">activesupport/lib/active_support/core_ext/hash/reverse_merge.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/hash/slice_rb.html">activesupport/lib/active_support/core_ext/hash/slice.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/object/blank_rb.html">activesupport/lib/active_support/core_ext/object/blank.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/object/deep_dup_rb.html">activesupport/lib/active_support/core_ext/object/deep_dup.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/object/json_rb.html">activesupport/lib/active_support/core_ext/object/json.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/object/to_query_rb.html">activesupport/lib/active_support/core_ext/object/to_query.rb</a></li>
            
        </ul>
    </div>
    <div id="bodyContent">
        <div id="content">
  

  

  
  


  

  
    <h2 id="methods">Methods</h2>
    <ul>
      
        <li>
          <a href="#method-i-assert_valid_keys">assert_valid_keys</a>
        </li>
      
        <li>
          <a href="#method-i-compact_blank-21">compact_blank!</a>
        </li>
      
        <li>
          <a href="#method-i-deep_dup">deep_dup</a>
        </li>
      
        <li>
          <a href="#method-i-deep_merge">deep_merge</a>
        </li>
      
        <li>
          <a href="#method-i-deep_stringify_keys">deep_stringify_keys</a>
        </li>
      
        <li>
          <a href="#method-i-deep_stringify_keys-21">deep_stringify_keys!</a>
        </li>
      
        <li>
          <a href="#method-i-deep_symbolize_keys">deep_symbolize_keys</a>
        </li>
      
        <li>
          <a href="#method-i-deep_symbolize_keys-21">deep_symbolize_keys!</a>
        </li>
      
        <li>
          <a href="#method-i-deep_transform_keys">deep_transform_keys</a>
        </li>
      
        <li>
          <a href="#method-i-deep_transform_keys-21">deep_transform_keys!</a>
        </li>
      
        <li>
          <a href="#method-i-deep_transform_values">deep_transform_values</a>
        </li>
      
        <li>
          <a href="#method-i-deep_transform_values-21">deep_transform_values!</a>
        </li>
      
        <li>
          <a href="#method-i-except-21">except!</a>
        </li>
      
        <li>
          <a href="#method-i-extract-21">extract!</a>
        </li>
      
        <li>
          <a href="#method-i-extractable_options-3F">extractable_options?</a>
        </li>
      
        <li>
          <a href="#method-c-from_trusted_xml">from_trusted_xml</a>
        </li>
      
        <li>
          <a href="#method-c-from_xml">from_xml</a>
        </li>
      
        <li>
          <a href="#method-i-nested_under_indifferent_access">nested_under_indifferent_access</a>
        </li>
      
        <li>
          <a href="#method-i-reverse_merge">reverse_merge</a>
        </li>
      
        <li>
          <a href="#method-i-reverse_merge-21">reverse_merge!</a>
        </li>
      
        <li>
          <a href="#method-i-reverse_update">reverse_update</a>
        </li>
      
        <li>
          <a href="#method-i-slice-21">slice!</a>
        </li>
      
        <li>
          <a href="#method-i-stringify_keys">stringify_keys</a>
        </li>
      
        <li>
          <a href="#method-i-stringify_keys-21">stringify_keys!</a>
        </li>
      
        <li>
          <a href="#method-i-symbolize_keys">symbolize_keys</a>
        </li>
      
        <li>
          <a href="#method-i-symbolize_keys-21">symbolize_keys!</a>
        </li>
      
        <li>
          <a href="#method-i-to_options">to_options</a>
        </li>
      
        <li>
          <a href="#method-i-to_options-21">to_options!</a>
        </li>
      
        <li>
          <a href="#method-i-to_param">to_param</a>
        </li>
      
        <li>
          <a href="#method-i-to_query">to_query</a>
        </li>
      
        <li>
          <a href="#method-i-to_xml">to_xml</a>
        </li>
      
        <li>
          <a href="#method-i-with_defaults">with_defaults</a>
        </li>
      
        <li>
          <a href="#method-i-with_defaults-21">with_defaults!</a>
        </li>
      
        <li>
          <a href="#method-i-with_indifferent_access">with_indifferent_access</a>
        </li>
      
    </ul>
  

  

  
    

    

    

    

    <!-- Methods -->
    
      <h2 id="class-public-methods">Class Public methods</h2>
      
        <div class="method">
          <h3 id="method-c-from_trusted_xml">
            
              from_trusted_xml(xml)
            
          </h3>

          
            <div class="description">
              <p>Builds a <a href="Hash.html"><code>Hash</code></a> from XML just like <code>Hash.from_xml</code>, but also allows <a href="Symbol.html"><code>Symbol</code></a> and YAML.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/hash/conversions.rb, line 133
    def from_trusted_xml(xml)
      from_xml xml, []
    end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/hash/conversions.rb#L133" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-c-from_xml">
            
              from_xml(xml, disallowed_types = nil)
            
          </h3>

          
            <div class="description">
              <p>Returns a <a href="Hash.html"><code>Hash</code></a> containing a collection of pairs when the key is the node name and the value is its content</p>

<pre><code>xml = &lt;&lt;-XML
  &lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;
    &lt;hash&gt;
      &lt;foo type=&quot;integer&quot;&gt;1&lt;/foo&gt;
      &lt;bar type=&quot;integer&quot;&gt;2&lt;/bar&gt;
    &lt;/hash&gt;
XML

hash = Hash.from_xml(xml)
# =&gt; {&quot;hash&quot;=&gt;{&quot;foo&quot;=&gt;1, &quot;bar&quot;=&gt;2}}
</code></pre>

<p><code>DisallowedType</code> is raised if the XML contains attributes with <code>type=&quot;yaml&quot;</code> or <code>type=&quot;symbol&quot;</code>. Use <code>Hash.from_trusted_xml</code> to parse this XML.</p>

<p>Custom <code>disallowed_types</code> can also be passed in the form of an array.</p>

<pre><code>xml = &lt;&lt;-XML
  &lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;
    &lt;hash&gt;
      &lt;foo type=&quot;integer&quot;&gt;1&lt;/foo&gt;
      &lt;bar type=&quot;string&quot;&gt;&quot;David&quot;&lt;/bar&gt;
    &lt;/hash&gt;
XML

hash = Hash.from_xml(xml, [&#39;integer&#39;])
# =&gt; ActiveSupport::XMLConverter::DisallowedType: Disallowed type attribute: &quot;integer&quot;
</code></pre>

<p>Note that passing custom disallowed types will override the default types, which are <a href="Symbol.html"><code>Symbol</code></a> and YAML.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/hash/conversions.rb, line 128
    def from_xml(xml, disallowed_types = nil)
      ActiveSupport::XMLConverter.new(xml, disallowed_types).to_h
    end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/hash/conversions.rb#L128" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
      
    
      <h2 id="instance-public-methods">Instance Public methods</h2>
      
        <div class="method">
          <h3 id="method-i-assert_valid_keys">
            
              assert_valid_keys(*valid_keys)
            
          </h3>

          
            <div class="description">
              <p>Validates all keys in a hash match <code>*valid_keys</code>, raising <code>ArgumentError</code> on a mismatch.</p>

<p>Note that keys are treated differently than <a href="ActiveSupport/HashWithIndifferentAccess.html"><code>HashWithIndifferentAccess</code></a>, meaning that string and symbol keys will not match.</p>

<pre><code>{ name: &#39;Rob&#39;, years: &#39;28&#39; }.assert_valid_keys(:name, :age) # =&gt; raises &quot;ArgumentError: Unknown key: :years. Valid keys are: :name, :age&quot;
{ name: &#39;Rob&#39;, age: &#39;28&#39; }.assert_valid_keys(&#39;name&#39;, &#39;age&#39;) # =&gt; raises &quot;ArgumentError: Unknown key: :name. Valid keys are: &#39;name&#39;, &#39;age&#39;&quot;
{ name: &#39;Rob&#39;, age: &#39;28&#39; }.assert_valid_keys(:name, :age)   # =&gt; passes, raises nothing
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/hash/keys.rb, line 48
  def assert_valid_keys(*valid_keys)
    valid_keys.flatten!
    each_key do |k|
      unless valid_keys.include?(k)
        raise ArgumentError.new(&quot;Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&amp;:inspect).join(&#39;, &#39;)}&quot;)
      end
    end
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/hash/keys.rb#L48" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-compact_blank-21">
            
              compact_blank!()
            
          </h3>

          
            <div class="description">
              <p>Removes all blank values from the <code>Hash</code> in place and returns self. Uses <a href="Object.html#method-i-blank-3F"><code>Object#blank?</code></a> for determining if a value is blank.</p>

<pre><code>h = { a: &quot;&quot;, b: 1, c: nil, d: [], e: false, f: true }
h.compact_blank!
# =&gt; { b: 1, f: true }
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/enumerable.rb, line 232
  def compact_blank!
    # use delete_if rather than reject! because it always returns self even if nothing changed
    delete_if { |_k, v| v.blank? }
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/enumerable.rb#L232" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-deep_dup">
            
              deep_dup()
            
          </h3>

          
            <div class="description">
              <p>Returns a deep copy of hash.</p>

<pre><code>hash = { a: { b: &#39;b&#39; } }
dup  = hash.deep_dup
dup[:a][:c] = &#39;c&#39;

hash[:a][:c] # =&gt; nil
dup[:a][:c]  # =&gt; &quot;c&quot;
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/object/deep_dup.rb, line 43
  def deep_dup
    hash = dup
    each_pair do |key, value|
      if ::String === key || ::Symbol === key
        hash[key] = value.deep_dup
      else
        hash.delete(key)
        hash[key.deep_dup] = value.deep_dup
      end
    end
    hash
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/object/deep_dup.rb#L43" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-deep_merge">
            
              deep_merge(other_hash, &block)

            
          </h3>

          
            <div class="description">
              <p>Returns a new hash with <code>self</code> and <code>other_hash</code> merged recursively.</p>

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

h1.deep_merge(h2) # =&gt; { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
</code></pre>

<p>Like with Hash#merge in the standard library, a block can be provided to merge values:</p>

<pre><code>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 }
# =&gt; { a: 100, b: 450, c: { c1: 300 } }
</code></pre>
            </div>
          

          

          

          
          
            <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/hash/deep_merge.rb#L9" target="_blank" class="github_url">🔎 See on GitHub</a>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-deep_stringify_keys">
            
              deep_stringify_keys()
            
          </h3>

          
            <div class="description">
              <p>Returns a new hash with all keys converted to strings. This includes the keys from the root hash and from all nested hashes and arrays.</p>

<pre><code>hash = { person: { name: &#39;Rob&#39;, age: &#39;28&#39; } }

hash.deep_stringify_keys
# =&gt; {&quot;person&quot;=&gt;{&quot;name&quot;=&gt;&quot;Rob&quot;, &quot;age&quot;=&gt;&quot;28&quot;}}
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/hash/keys.rb, line 84
  def deep_stringify_keys
    deep_transform_keys { |k| Symbol === k ? k.name : k.to_s }
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/hash/keys.rb#L84" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-deep_stringify_keys-21">
            
              deep_stringify_keys!()
            
          </h3>

          
            <div class="description">
              <p>Destructively converts all keys to strings. This includes the keys from the root hash and from all nested hashes and arrays.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/hash/keys.rb, line 91
  def deep_stringify_keys!
    deep_transform_keys! { |k| Symbol === k ? k.name : k.to_s }
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/hash/keys.rb#L91" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-deep_symbolize_keys">
            
              deep_symbolize_keys()
            
          </h3>

          
            <div class="description">
              <p>Returns a new hash with all keys converted to symbols, as long as they respond to <code>to_sym</code>. This includes the keys from the root hash and from all nested hashes and arrays.</p>

<pre><code>hash = { &#39;person&#39; =&gt; { &#39;name&#39; =&gt; &#39;Rob&#39;, &#39;age&#39; =&gt; &#39;28&#39; } }

hash.deep_symbolize_keys
# =&gt; {:person=&gt;{:name=&gt;&quot;Rob&quot;, :age=&gt;&quot;28&quot;}}
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/hash/keys.rb, line 103
  def deep_symbolize_keys
    deep_transform_keys { |key| key.to_sym rescue key }
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/hash/keys.rb#L103" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-deep_symbolize_keys-21">
            
              deep_symbolize_keys!()
            
          </h3>

          
            <div class="description">
              <p>Destructively converts all keys to symbols, as long as they respond to <code>to_sym</code>. This includes the keys from the root hash and from all nested hashes and arrays.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/hash/keys.rb, line 110
  def deep_symbolize_keys!
    deep_transform_keys! { |key| key.to_sym rescue key }
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/hash/keys.rb#L110" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-deep_transform_keys">
            
              deep_transform_keys(&amp;block)
            
          </h3>

          
            <div class="description">
              <p>Returns a new hash with all keys converted by the block operation. This includes the keys from the root hash and from all nested hashes and arrays.</p>

<pre><code>hash = { person: { name: &#39;Rob&#39;, age: &#39;28&#39; } }

hash.deep_transform_keys{ |key| key.to_s.upcase }
# =&gt; {&quot;PERSON&quot;=&gt;{&quot;NAME&quot;=&gt;&quot;Rob&quot;, &quot;AGE&quot;=&gt;&quot;28&quot;}}
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/hash/keys.rb, line 65
  def deep_transform_keys(&amp;block)
    _deep_transform_keys_in_object(self, &amp;block)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/hash/keys.rb#L65" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-deep_transform_keys-21">
            
              deep_transform_keys!(&amp;block)
            
          </h3>

          
            <div class="description">
              <p>Destructively converts all keys by using the block operation. This includes the keys from the root hash and from all nested hashes and arrays.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/hash/keys.rb, line 72
  def deep_transform_keys!(&amp;block)
    _deep_transform_keys_in_object!(self, &amp;block)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/hash/keys.rb#L72" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-deep_transform_values">
            
              deep_transform_values(&amp;block)
            
          </h3>

          
            <div class="description">
              <p>Returns a new hash with all values converted by the block operation. This includes the values from the root hash and from all nested hashes and arrays.</p>

<pre><code>hash = { person: { name: &#39;Rob&#39;, age: &#39;28&#39; } }

hash.deep_transform_values{ |value| value.to_s.upcase }
# =&gt; {person: {name: &quot;ROB&quot;, age: &quot;28&quot;}}
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/hash/deep_transform_values.rb, line 12
  def deep_transform_values(&amp;block)
    _deep_transform_values_in_object(self, &amp;block)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/hash/deep_transform_values.rb#L12" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-deep_transform_values-21">
            
              deep_transform_values!(&amp;block)
            
          </h3>

          
            <div class="description">
              <p>Destructively converts all values by using the block operation. This includes the values from the root hash and from all nested hashes and arrays.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/hash/deep_transform_values.rb, line 19
  def deep_transform_values!(&amp;block)
    _deep_transform_values_in_object!(self, &amp;block)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/hash/deep_transform_values.rb#L19" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-except-21">
            
              except!(*keys)
            
          </h3>

          
            <div class="description">
              <p>Removes the given keys from hash and returns it.</p>

<pre><code>hash = { a: true, b: false, c: nil }
hash.except!(:c) # =&gt; { a: true, b: false }
hash             # =&gt; { a: true, b: false }
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/hash/except.rb, line 8
  def except!(*keys)
    keys.each { |key| delete(key) }
    self
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/hash/except.rb#L8" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-extract-21">
            
              extract!(*keys)
            
          </h3>

          
            <div class="description">
              <p>Removes and returns the key/value pairs matching the given keys.</p>

<pre><code>hash = { a: 1, b: 2, c: 3, d: 4 }
hash.extract!(:a, :b) # =&gt; {:a=&gt;1, :b=&gt;2}
hash                  # =&gt; {:c=&gt;3, :d=&gt;4}
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/hash/slice.rb, line 24
  def extract!(*keys)
    keys.each_with_object(self.class.new) { |key, result| result[key] = delete(key) if has_key?(key) }
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/hash/slice.rb#L24" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-extractable_options-3F">
            
              extractable_options?()
            
          </h3>

          
            <div class="description">
              <p>By default, only instances of <a href="Hash.html"><code>Hash</code></a> itself are extractable. Subclasses of <a href="Hash.html"><code>Hash</code></a> may implement this method and return true to declare themselves as extractable. If a <a href="Hash.html"><code>Hash</code></a> is extractable, <a href="Array.html#method-i-extract_options-21"><code>Array#extract_options!</code></a> pops it from the <a href="Array.html"><code>Array</code></a> when it is the last element of the <a href="Array.html"><code>Array</code></a>.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/array/extract_options.rb, line 9
  def extractable_options?
    instance_of?(Hash)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/array/extract_options.rb#L9" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-nested_under_indifferent_access">
            
              nested_under_indifferent_access()
            
          </h3>

          
            <div class="description">
              <p>Called when object is nested under an object that receives <a href="Hash.html#method-i-with_indifferent_access"><code>with_indifferent_access</code></a>. This method will be called on the current object by the enclosing object and is aliased to <a href="Hash.html#method-i-with_indifferent_access"><code>with_indifferent_access</code></a> by default. Subclasses of <a href="Hash.html"><code>Hash</code></a> may override this method to return <code>self</code> if converting to an <a href="ActiveSupport/HashWithIndifferentAccess.html"><code>ActiveSupport::HashWithIndifferentAccess</code></a> would not be desirable.</p>

<pre><code>b = { b: 1 }
{ a: b }.with_indifferent_access[&#39;a&#39;] # calls b.nested_under_indifferent_access
# =&gt; {&quot;b&quot;=&gt;1}
</code></pre>
            </div>
          

          

          
            <div class="aka">
              Alias for: <a href="Hash.html#method-i-with_indifferent_access">with_indifferent_access</a>
            </div>
          

          
          
        </div>
        
        <div class="method">
          <h3 id="method-i-reverse_merge">
            
              reverse_merge(other_hash)
            
          </h3>

          
            <div class="description">
              <p>Merges the caller into <code>other_hash</code>. For example,</p>

<pre><code>options = options.reverse_merge(size: 25, velocity: 10)
</code></pre>

<p>is equivalent to</p>

<pre><code>options = { size: 25, velocity: 10 }.merge(options)
</code></pre>

<p>This is particularly useful for initializing an options hash with default values.</p>
            </div>
          

          
            <div class="aka">
              Also aliased as: <a href="Hash.html#method-i-with_defaults">with_defaults</a>
            </div>
          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/hash/reverse_merge.rb, line 14
  def reverse_merge(other_hash)
    other_hash.merge(self)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/hash/reverse_merge.rb#L14" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-reverse_merge-21">
            
              reverse_merge!(other_hash)
            
          </h3>

          
            <div class="description">
              <p>Destructive <code>reverse_merge</code>.</p>
            </div>
          

          
            <div class="aka">
              Also aliased as: <a href="Hash.html#method-i-reverse_update">reverse_update</a>, <a href="Hash.html#method-i-with_defaults-21">with_defaults!</a>
            </div>
          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/hash/reverse_merge.rb, line 20
  def reverse_merge!(other_hash)
    replace(reverse_merge(other_hash))
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/hash/reverse_merge.rb#L20" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-reverse_update">
            
              reverse_update(other_hash)
            
          </h3>

          
            <div class="description">
              
            </div>
          

          

          
            <div class="aka">
              Alias for: <a href="Hash.html#method-i-reverse_merge-21">reverse_merge!</a>
            </div>
          

          
          
        </div>
        
        <div class="method">
          <h3 id="method-i-slice-21">
            
              slice!(*keys)
            
          </h3>

          
            <div class="description">
              <p>Replaces the hash with only the given keys. Returns a hash containing the removed key/value pairs.</p>

<pre><code>hash = { a: 1, b: 2, c: 3, d: 4 }
hash.slice!(:a, :b)  # =&gt; {:c=&gt;3, :d=&gt;4}
hash                 # =&gt; {:a=&gt;1, :b=&gt;2}
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/hash/slice.rb, line 10
  def slice!(*keys)
    omit = slice(*self.keys - keys)
    hash = slice(*keys)
    hash.default      = default
    hash.default_proc = default_proc if default_proc
    replace(hash)
    omit
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/hash/slice.rb#L10" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-stringify_keys">
            
              stringify_keys()
            
          </h3>

          
            <div class="description">
              <p>Returns a new hash with all keys converted to strings.</p>

<pre><code>hash = { name: &#39;Rob&#39;, age: &#39;28&#39; }

hash.stringify_keys
# =&gt; {&quot;name&quot;=&gt;&quot;Rob&quot;, &quot;age&quot;=&gt;&quot;28&quot;}
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/hash/keys.rb, line 10
  def stringify_keys
    transform_keys { |k| Symbol === k ? k.name : k.to_s }
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/hash/keys.rb#L10" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-stringify_keys-21">
            
              stringify_keys!()
            
          </h3>

          
            <div class="description">
              <p>Destructively converts all keys to strings. Same as <code>stringify_keys</code>, but modifies <code>self</code>.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/hash/keys.rb, line 16
  def stringify_keys!
    transform_keys! { |k| Symbol === k ? k.name : k.to_s }
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/hash/keys.rb#L16" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-symbolize_keys">
            
              symbolize_keys()
            
          </h3>

          
            <div class="description">
              <p>Returns a new hash with all keys converted to symbols, as long as they respond to <code>to_sym</code>.</p>

<pre><code>hash = { &#39;name&#39; =&gt; &#39;Rob&#39;, &#39;age&#39; =&gt; &#39;28&#39; }

hash.symbolize_keys
# =&gt; {:name=&gt;&quot;Rob&quot;, :age=&gt;&quot;28&quot;}
</code></pre>
            </div>
          

          
            <div class="aka">
              Also aliased as: <a href="Hash.html#method-i-to_options">to_options</a>
            </div>
          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/hash/keys.rb, line 27
  def symbolize_keys
    transform_keys { |key| key.to_sym rescue key }
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/hash/keys.rb#L27" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-symbolize_keys-21">
            
              symbolize_keys!()
            
          </h3>

          
            <div class="description">
              <p>Destructively converts all keys to symbols, as long as they respond to <code>to_sym</code>. Same as <code>symbolize_keys</code>, but modifies <code>self</code>.</p>
            </div>
          

          
            <div class="aka">
              Also aliased as: <a href="Hash.html#method-i-to_options-21">to_options!</a>
            </div>
          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/hash/keys.rb, line 34
  def symbolize_keys!
    transform_keys! { |key| key.to_sym rescue key }
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/hash/keys.rb#L34" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-to_options">
            
              to_options()
            
          </h3>

          
            <div class="description">
              
            </div>
          

          

          
            <div class="aka">
              Alias for: <a href="Hash.html#method-i-symbolize_keys">symbolize_keys</a>
            </div>
          

          
          
        </div>
        
        <div class="method">
          <h3 id="method-i-to_options-21">
            
              to_options!()
            
          </h3>

          
            <div class="description">
              
            </div>
          

          

          
            <div class="aka">
              Alias for: <a href="Hash.html#method-i-symbolize_keys-21">symbolize_keys!</a>
            </div>
          

          
          
        </div>
        
        <div class="method">
          <h3 id="method-i-to_param">
            
              to_param(namespace = nil)
            
          </h3>

          
            <div class="description">
              
            </div>
          

          

          
            <div class="aka">
              Alias for: <a href="Hash.html#method-i-to_query">to_query</a>
            </div>
          

          
          
        </div>
        
        <div class="method">
          <h3 id="method-i-to_query">
            
              to_query(namespace = nil)
            
          </h3>

          
            <div class="description">
              <p>Returns a string representation of the receiver suitable for use as a URL query string:</p>

<pre><code>{name: &#39;David&#39;, nationality: &#39;Danish&#39;}.to_query
# =&gt; &quot;name=David&amp;nationality=Danish&quot;
</code></pre>

<p>An optional namespace can be passed to enclose key names:</p>

<pre><code>{name: &#39;David&#39;, nationality: &#39;Danish&#39;}.to_query(&#39;user&#39;)
# =&gt; &quot;user%5Bname%5D=David&amp;user%5Bnationality%5D=Danish&quot;
</code></pre>

<p>The string pairs “key=value” that conform the query string are sorted lexicographically in ascending order.</p>
            </div>
          

          
            <div class="aka">
              Also aliased as: <a href="Hash.html#method-i-to_param">to_param</a>
            </div>
          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/object/to_query.rb, line 75
  def to_query(namespace = nil)
    query = filter_map do |key, value|
      unless (value.is_a?(Hash) || value.is_a?(Array)) &amp;&amp; value.empty?
        value.to_query(namespace ? &quot;#{namespace}[#{key}]&quot; : key)
      end
    end

    query.sort! unless namespace.to_s.include?(&quot;[]&quot;)
    query.join(&quot;&amp;&quot;)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/object/to_query.rb#L75" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-to_xml">
            
              to_xml(options = {})
            
          </h3>

          
            <div class="description">
              <p>Returns a string containing an XML representation of its receiver:</p>

<pre><code>{ foo: 1, bar: 2 }.to_xml
# =&gt;
# &lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;
# &lt;hash&gt;
#   &lt;foo type=&quot;integer&quot;&gt;1&lt;/foo&gt;
#   &lt;bar type=&quot;integer&quot;&gt;2&lt;/bar&gt;
# &lt;/hash&gt;
</code></pre>

<p>To do so, the method loops over the pairs and builds nodes that depend on the <em>values</em>. Given a pair <code>key</code>, <code>value</code>:</p>
<ul><li>
<p>If <code>value</code> is a hash there’s a recursive call with <code>key</code> as <code>:root</code>.</p>
</li><li>
<p>If <code>value</code> is an array there’s a recursive call with <code>key</code> as <code>:root</code>, and <code>key</code> singularized as <code>:children</code>.</p>
</li><li>
<p>If <code>value</code> is a callable object it must expect one or two arguments. Depending on the arity, the callable is invoked with the <code>options</code> hash as first argument with <code>key</code> as <code>:root</code>, and <code>key</code> singularized as second argument. The callable can add nodes by using <code>options[:builder]</code>.</p>

<pre><code>{foo: lambda { |options, key| options[:builder].b(key) }}.to_xml
# =&gt; &quot;&lt;b&gt;foo&lt;/b&gt;&quot;
</code></pre>
</li><li>
<p>If <code>value</code> responds to <code>to_xml</code> the method is invoked with <code>key</code> as <code>:root</code>.</p>

<pre><code>class Foo
  def to_xml(options)
    options[:builder].bar &#39;fooing!&#39;
  end
end

{ foo: Foo.new }.to_xml(skip_instruct: true)
# =&gt;
# &lt;hash&gt;
#   &lt;bar&gt;fooing!&lt;/bar&gt;
# &lt;/hash&gt;
</code></pre>
</li><li>
<p>Otherwise, a node with <code>key</code> as tag is created with a string representation of <code>value</code> as text node. If <code>value</code> is <code>nil</code> an attribute “nil” set to “true” is added. Unless the option <code>:skip_types</code> exists and is true, an attribute “type” is added as well according to the following mapping:</p>

<pre><code>XML_TYPE_NAMES = {
  &quot;Symbol&quot;     =&gt; &quot;symbol&quot;,
  &quot;Integer&quot;    =&gt; &quot;integer&quot;,
  &quot;BigDecimal&quot; =&gt; &quot;decimal&quot;,
  &quot;Float&quot;      =&gt; &quot;float&quot;,
  &quot;TrueClass&quot;  =&gt; &quot;boolean&quot;,
  &quot;FalseClass&quot; =&gt; &quot;boolean&quot;,
  &quot;Date&quot;       =&gt; &quot;date&quot;,
  &quot;DateTime&quot;   =&gt; &quot;dateTime&quot;,
  &quot;Time&quot;       =&gt; &quot;dateTime&quot;
}
</code></pre>
</li></ul>

<p>By default the root node is “hash”, but that’s configurable via the <code>:root</code> option.</p>

<p>The default XML builder is a fresh instance of <code>Builder::XmlMarkup</code>. You can configure your own builder with the <code>:builder</code> option. The method also accepts options like <code>:dasherize</code> and friends, they are forwarded to the builder.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/hash/conversions.rb, line 74
  def to_xml(options = {})
    require &quot;active_support/builder&quot; unless defined?(Builder::XmlMarkup)

    options = options.dup
    options[:indent]  ||= 2
    options[:root]    ||= &quot;hash&quot;
    options[:builder] ||= Builder::XmlMarkup.new(indent: options[:indent])

    builder = options[:builder]
    builder.instruct! unless options.delete(:skip_instruct)

    root = ActiveSupport::XmlMini.rename_key(options[:root].to_s, options)

    builder.tag!(root) do
      each { |key, value| ActiveSupport::XmlMini.to_tag(key, value, options) }
      yield builder if block_given?
    end
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/hash/conversions.rb#L74" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-with_defaults">
            
              with_defaults(other_hash)
            
          </h3>

          
            <div class="description">
              
            </div>
          

          

          
            <div class="aka">
              Alias for: <a href="Hash.html#method-i-reverse_merge">reverse_merge</a>
            </div>
          

          
          
        </div>
        
        <div class="method">
          <h3 id="method-i-with_defaults-21">
            
              with_defaults!(other_hash)
            
          </h3>

          
            <div class="description">
              
            </div>
          

          

          
            <div class="aka">
              Alias for: <a href="Hash.html#method-i-reverse_merge-21">reverse_merge!</a>
            </div>
          

          
          
        </div>
        
        <div class="method">
          <h3 id="method-i-with_indifferent_access">
            
              with_indifferent_access()
            
          </h3>

          
            <div class="description">
              <p>Returns an <a href="ActiveSupport/HashWithIndifferentAccess.html"><code>ActiveSupport::HashWithIndifferentAccess</code></a> out of its receiver:</p>

<pre><code>{ a: 1 }.with_indifferent_access[&#39;a&#39;] # =&gt; 1
</code></pre>
            </div>
          

          
            <div class="aka">
              Also aliased as: <a href="Hash.html#method-i-nested_under_indifferent_access">nested_under_indifferent_access</a>
            </div>
          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/hash/indifferent_access.rb, line 9
  def with_indifferent_access
    ActiveSupport::HashWithIndifferentAccess.new(self)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/hash/indifferent_access.rb#L9" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
      
    
  
</div>

    </div>
</div>