Class | HashWithIndifferentAccess
In: | lib/active_support/core_ext/hash/indifferent_access.rb
Parent: | Hash

This class has dubious semantics and we only have it so that people can write params[:key] instead of params[‘key’] and they get the same value for both keys.

### Methods

[]= convert_key convert_value default delete dup fetch key? merge new reverse_merge stringify_keys! symbolize_keys! to_hash to_options! update values_at

### External Aliases

[]= | -> | regular_writer

### Public Class methods

new(constructor = {})

### Public Instance methods

[]=(key, value)

Assigns a new value to the hash:

      hash = HashWithIndifferentAccess.new
      hash[:key] = "value"

convert_key(key)
convert_value(value)
default(key = nil)
delete(key)

Removes a specified key from the hash.

dup()

Returns an exact copy of the hash.

fetch(key, *extras)

Fetches the value for the specified key, same as doing hash[key]

key?(key)

Checks the hash for a key matching the argument passed in:

      hash = HashWithIndifferentAccess.new
      hash["key"] = "value"
      hash.key? :key  # => true
      hash.key? "key" # => true

merge(hash)

Merges the instantized and the specified hashes together, giving precedence to the values from the second hash Does not overwrite the existing hash.

reverse_merge(other_hash)

Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second. This overloaded definition prevents returning a regular hash, if reverse_merge is called on a HashWithDifferentAccess.

stringify_keys!()
symbolize_keys!()
to_hash()

Convert to a Hash with String keys.

to_options!()
update(other_hash)

Updates the instantized hash with values from the second:

      hash_1 = HashWithIndifferentAccess.new
      hash_1[:key] = "value"

      hash_2 = HashWithIndifferentAccess.new
      hash_2[:key] = "New Value!"

      hash_1.update(hash_2) # => {"key"=>"New Value!"}

values_at(*indices)

Returns an array of the values at the specified indices:

      hash = HashWithIndifferentAccess.new
      hash[:a] = "x"
      hash[:b] = "y"
      hash.values_at("a", "b") # => ["x", "y"]

[Validate]