Class: Hash

Duplicates a given hash and adds a ruby2_keywords flag. This method is not for casual use; debugging, researching, and some truly necessary cases like deserialization of arguments.

h = {k: 1}
h = Hash.ruby2_keywords_hash(h)
def foo(k: 42)
  k
end
foo(*[h]) #=> 1 with neither a warning or an error

Checks if a given hash is flagged by Module#ruby2_keywords (or Proc#ruby2_keywords). This method is not for casual use; debugging, researching, and some truly necessary cases like serialization of arguments.

ruby2_keywords def foo(*args)
  Hash.ruby2_keywords_hash?(args.last)
end
foo(k: 1)   #=> true
foo({k: 1}) #=> false

If object is a hash, returns object.

Otherwise if object responds to :to_hash, calls object.to_hash; returns the result if it is a hash, or raises ::TypeError if not.

Otherwise if object does not respond to :to_hash, returns nil.

Returns whether #compare_by_identity has been called:

h = {}
h.compare_by_identity? # => false
h.compare_by_identity
h.compare_by_identity? # => true

Related: #compare_by_identity; see also Methods for Comparing.

Returns the default proc for self (see Hash Default):

h = {}
h.default_proc # => nil
h.default_proc = proc {|hash, key| "Default value for #{key}" }
h.default_proc.class # => Proc

Sets the default proc for self to proc (see Hash Default):

h = {}
h.default_proc # => nil
h.default_proc = proc { |hash, key| "Default value for #{key}" }
h.default_proc.class # => Proc
h.default_proc = nil
h.default_proc # => nil

Returns true if there are no hash entries, false otherwise:

{}.empty? # => true
{foo: 0}.empty? # => false

Related: see Methods for Querying.

Returns true if the entries of self are a subset of the entries of other_hash, false otherwise:

h0 = {foo: 0, bar: 1}
h1 = {foo: 0, bar: 1, baz: 2}
h0 <= h0 # => true
h0 <= h1 # => true
h1 <= h0 # => false

See Hash Inclusion.

Raises TypeError if other_hash is not a hash and cannot be converted to a hash.

Related: see Methods for Comparing.

Returns whether self and object are equal.

Returns true if all of the following are true:

• object is a Hash object (or can be converted to one).

• self and object have the same keys (regardless of order).

• For each key #key, self[key] == object[key].

Otherwise, returns false.

Examples:

h =  {foo: 0, bar: 1}
h == {foo: 0, bar: 1} # => true   # Equal entries (same order)
h == {bar: 1, foo: 0} # => true   # Equal entries (different order).
h == 1                            # => false  # Object not a hash.
h == {}                           # => false  # Different number of entries.
h == {foo: 0, bar: 1} # => false  # Different key.
h == {foo: 0, bar: 1} # => false  # Different value.

Related: see Methods for Comparing.

Returns true if the entries of self are a proper superset of the entries of other_hash, false otherwise:

h = {foo: 0, bar: 1, baz: 2}
h > {foo: 0, bar: 1}         # => true   # Proper superset.
h > {bar: 1, foo: 0}         # => true   # Order may differ.
h > h                        # => false  # Not a proper superset.
h > {baz: 2, bar: 1, foo: 0} # => false  # Not a proper superset.
h > {foo: 0, bar: 1}         # => false  # Different key.
h > {foo: 0, bar: 1}         # => false  # Different value.

See Hash Inclusion.

Raises TypeError if other_hash is not a hash and cannot be converted to a hash.

Related: see Methods for Comparing.

Returns true if the entries of self are a superset of the entries of other_hash, false otherwise:

h0 = {foo: 0, bar: 1, baz: 2}
h1 = {foo: 0, bar: 1}
h0 >= h1 # => true
h0 >= h0 # => true
h1 >= h0 # => false

See Hash Inclusion.

Raises TypeError if other_hash is not a hash and cannot be converted to a hash.

Related: see Methods for Comparing.

Searches for a hash key equivalent to the given #key; see Hash Key Equivalence.

If the key is found, returns its value:

{foo: 0, bar: 1, baz: 2}
h[:bar] # => 1

Otherwise, returns a default value (see Hash Default).

Related: #[]=; see also Methods for Fetching.

Associates the given object with the given #key; returns object.

Searches for a hash key equivalent to the given #key; see Hash Key Equivalence.

If the key is found, replaces its value with the given object; the ordering is not affected (see Entry Order):

h = {foo: 0, bar: 1}
h[:foo] = 2 # => 2
h[:foo]     # => 2

If #key is not found, creates a new entry for the given #key and object; the new entry is last in the order (see Entry Order):

h = {foo: 0, bar: 1}
h[:baz] = 2 # => 2
h[:baz]     # => 2
h           # => {:foo=>0, :bar=>1, :baz=>2}

Related: #[]; see also Methods for Assigning.

Returns true if any element satisfies a given criterion; false otherwise.

If self has no element, returns false and argument or block are not used; otherwise behaves as below.

With no argument and no block, returns true if self is non-empty, false otherwise.

With argument entry and no block, returns true if for any key #key self.assoc(key) == entry, false otherwise:

h = {foo: 0, bar: 1, baz: 2}
h.assoc(:bar)     # => [:bar, 1]
h.any?([:bar, 1]) # => true
h.any?([:bar, 0]) # => false

With no argument and a block given, calls the block with each key-value pair; returns true if the block returns a truthy value, false otherwise:

h = {foo: 0, bar: 1, baz: 2}
h.any? {|key, value| value < 3 } # => true
h.any? {|key, value| value > 3 } # => false

With both argument entry and a block given, issues a warning and ignores the block.

Related: Enumerable#any? (which this method overrides); see also Methods for Fetching.

If the given #key is found, returns its entry as a 2-element array containing that key and its value:

h = {foo: 0, bar: 1, baz: 2}
h.assoc(:bar) # => [:bar, 1]

Returns nil if the key is not found.

Related: see Methods for Fetching.

Removes all entries from self; returns emptied self.

Related: see Methods for Deleting.

Returns a copy of self with all nil-valued entries removed:

h = {foo: 0, bar: nil, baz: 2, bat: nil}
h.compact # => {foo: 0, baz: 2}

Related: see Methods for Deleting.

If self contains any nil-valued entries, returns self with all nil-valued entries removed; returns nil otherwise:

h = {foo: 0, bar: nil, baz: 2, bat: nil}
h.compact!
h          # => {foo: 0, baz: 2}
h.compact! # => nil

Related: see Methods for Deleting.

Returns the default value for the given #key. The returned value will be determined either by the default proc or by the default value. See Hash Default.

With no argument, returns the current default value:

h = {}
h.default # => nil

If #key is given, returns the default value for #key, regardless of whether that key exists:

h = Hash.new { |hash, key| hash[key] = "No key #{key}"}
h[:foo] = "Hello"
h.default(:foo) # => "No key foo"

Sets the default value to value; returns value:

h = {}
h.default # => nil
h.default = false # => false
h.default # => false

See Hash Default.

If an entry for the given #key is found, deletes the entry and returns its associated value; otherwise returns nil or calls the given block.

With no block given and #key found, deletes the entry and returns its value:

h = {foo: 0, bar: 1, baz: 2}
h.delete(:bar) # => 1
h # => {foo: 0, baz: 2}

With no block given and #key not found, returns nil.

With a block given and #key found, ignores the block, deletes the entry, and returns its value:

h = {foo: 0, bar: 1, baz: 2}
h.delete(:baz) { |key| raise 'Will never happen'} # => 2
h # => {foo: 0, bar: 1}

With a block given and #key not found, calls the block and returns the block’s return value:

h = {foo: 0, bar: 1, baz: 2}
h.delete(:nosuch) { |key| "Key #{key} not found" } # => "Key nosuch not found"
h # => {foo: 0, bar: 1, baz: 2}

Related: see Methods for Deleting.

With a block given, calls the block with each key-value pair, deletes each entry for which the block returns a truthy value, and returns self:

h = {foo: 0, bar: 1, baz: 2}
h.delete_if {|key, value| value > 0 } # => {foo: 0}

With no block given, returns a new ::Enumerator.

Related: see Methods for Deleting.

Finds and returns an object found in nested objects, as specified by #key and identifiers.

The nested objects may be instances of various classes. See Dig Methods.

Nested hashes:

h = {foo: {bar: {baz: 2}}}
h.dig(:foo) # => {bar: {baz: 2}}
h.dig(:foo, :bar) # => {baz: 2}
h.dig(:foo, :bar, :baz) # => 2
h.dig(:foo, :bar, :BAZ) # => nil

Nested hashes and arrays:

h = {foo: {bar: [:a, :b, :c]}}
h.dig(:foo, :bar, 2) # => :c

If no such object is found, returns the hash default:

h = {foo: {bar: [:a, :b, :c]}}
h.dig(:hello) # => nil
h.default_proc = -> (hash, _key) { hash }
h.dig(:hello, :world)
# => {:foo=>{:bar=>[:a, :b, :c]}}

Related: Methods for Fetching.

With a block given, calls the block with each key-value pair; returns self:

h = {foo: 0, bar: 1, baz: 2}
h.each_pair {|key, value| puts "#{key}: #{value}"} # => {foo: 0, bar: 1, baz: 2}

Output:

foo: 0
bar: 1
baz: 2

With no block given, returns a new ::Enumerator.

Related: see Methods for Iterating.

With a block given, calls the block with each key; returns self:

h = {foo: 0, bar: 1, baz: 2}
h.each_key {|key| puts key }  # => {foo: 0, bar: 1, baz: 2}

Output:

foo
bar
baz

With no block given, returns a new ::Enumerator.

Related: see Methods for Iterating.

Alias for #each.

With a block given, calls the block with each value; returns self:

h = {foo: 0, bar: 1, baz: 2}
h.each_value {|value| puts value } # => {foo: 0, bar: 1, baz: 2}

Output:

0
1
2

With no block given, returns a new ::Enumerator.

Related: see Methods for Iterating.

Returns true if all of the following are true:

• The given object is a Hash object.

• self and object have the same keys (regardless of order).

• For each key #key, self[key].eql?(object[key]).

Otherwise, returns false.

h1 = {foo: 0, bar: 1, baz: 2}
h2 = {foo: 0, bar: 1, baz: 2}
h1.eql? h2 # => true
h3 = {baz: 2, bar: 1, foo: 0}
h1.eql? h3 # => true

Related: see Methods for Querying.

Returns a copy of self that excludes entries for the given #keys; any #keys that are not found are ignored:

h = {foo:0, bar: 1, baz: 2} # => {:foo=>0, :bar=>1, :baz=>2}
h.except(:baz, :foo)        # => {:bar=>1}
h.except(:bar, :nosuch)     # => {:foo=>0, :baz=>2}

Related: see Methods for Deleting.

With no block given, returns the value for the given #key, if found;

h = {foo: 0, bar: 1, baz: 2}
h.fetch(:bar)  # => 1

If the key is not found, returns default_value, if given, or raises ::KeyError otherwise:

h.fetch(:nosuch, :default) # => :default
h.fetch(:nosuch)           # Raises KeyError.

With a block given, calls the block with #key and returns the block’s return value:

{}.fetch(:nosuch) {|key| "No key #{key}"} # => "No key nosuch"

Note that this method does not use the values of either #default or #default_proc.

Related: see Methods for Fetching.

When all given #keys are found, returns a new array containing the values associated with the given #keys:

h = {foo: 0, bar: 1, baz: 2}
h.fetch_values(:baz, :foo) # => [2, 0]

When any given #keys are not found and a block is given, calls the block with each unfound key and uses the block’s return value as the value for that key:

h.fetch_values(:bar, :foo, :bad, :bam) {|key| key.to_s}
# => [1, 0, "bad", "bam"]

When any given #keys are not found and no block is given, raises ::KeyError.

Related: see Methods for Fetching.

With a block given, calls the block with each entry’s key and value; returns a new hash whose entries are those for which the block returns a truthy value:

h = {foo: 0, bar: 1, baz: 2}
h.select {|key, value| value < 2 } # => {foo: 0, bar: 1}

With no block given, returns a new ::Enumerator.

Related: see Methods for Deleting.

With a block given, calls the block with each entry’s key and value; removes from self each entry for which the block returns false or nil.

Returns self if any entries were removed, nil otherwise:

h = {foo: 0, bar: 1, baz: 2}
h.select! {|key, value| value < 2 } # => {foo: 0, bar: 1}
h.select! {|key, value| value < 2 } # => nil

With no block given, returns a new ::Enumerator.

Related: see Methods for Deleting.

With positive integer depth, returns a new array that is a recursive flattening of self to the given depth.

At each level of recursion:

• Each element whose value is an array is “flattened” (that is, replaced by its individual array elements); see Array#flatten.

• Each element whose value is not an array is unchanged. even if the value is an object that has instance method flatten (such as a hash).

Examples; note that entry foo: {bar: 1, baz: 2} is never flattened.

h = {foo: {bar: 1, baz: 2}, bat: [:bam, [:bap, [:bah]]]}
h.flatten(1) # => [:foo, {:bar=>1, :baz=>2}, :bat, [:bam, [:bap, [:bah]]]]
h.flatten(2) # => [:foo, {:bar=>1, :baz=>2}, :bat, :bam, [:bap, [:bah]]]
h.flatten(3) # => [:foo, {:bar=>1, :baz=>2}, :bat, :bam, :bap, [:bah]]
h.flatten(4) # => [:foo, {:bar=>1, :baz=>2}, :bat, :bam, :bap, :bah]
h.flatten(5) # => [:foo, {:bar=>1, :baz=>2}, :bat, :bam, :bap, :bah]

With negative integer depth, flattens all levels:

h.flatten(-1) # => [:foo, {:bar=>1, :baz=>2}, :bat, :bam, :bap, :bah]

With depth zero, returns the equivalent of #to_a:

h.flatten(0) # => [[:foo, {:bar=>1, :baz=>2}], [:bat, [:bam, [:bap, [:bah]]]]]

Related: see Methods for Converting.

Alias for #key?.

Alias for #value?.

Returns the integer hash-code for the hash.

Two hashes have the same hash-code if their content is the same (regardless of order):

h1 = {foo: 0, bar: 1, baz: 2}
h2 = {baz: 2, bar: 1, foo: 0}
h2.hash == h1.hash # => true
h2.eql? h1 # => true

Related: see Methods for Querying.

Alias for #key?.

Alias for #replace.

Alias for #to_s.

Returns a new hash with each key-value pair inverted:

h = {foo: 0, bar: 1, baz: 2}
h1 = h.invert
h1 # => {0=>:foo, 1=>:bar, 2=>:baz}

Overwrites any repeated new keys (see Entry Order):

h = {foo: 0, bar: 0, baz: 0}
h.invert # => {0=>:baz}

Related: see Methods for Transforming Keys and Values.

With a block given, calls the block for each key-value pair; retains the entry if the block returns a truthy value; otherwise deletes the entry; returns self:

h = {foo: 0, bar: 1, baz: 2}
h.keep_if { |key, value| key.start_with?('b') } # => {bar: 1, baz: 2}

With no block given, returns a new ::Enumerator.

Related: see Methods for Deleting.

Returns the key for the first-found entry with the given value (see Entry Order):

h = {foo: 0, bar: 2, baz: 2}
h.key(0) # => :foo
h.key(2) # => :bar

Returns nil if no such value is found.

Related: see Methods for Fetching.

Returns whether #key is a key in self:

h = {foo: 0, bar: 1, baz: 2}
h.include?(:bar) # => true
h.include?(:BAR) # => false

Related: Methods for Querying.

Returns a new array containing all keys in self:

h = {foo: 0, bar: 1, baz: 2}
h.keys # => [:foo, :bar, :baz]

Related: see Methods for Fetching.

Returns the count of entries in self:

{foo: 0, bar: 1, baz: 2}.size # => 3

Related: see Methods for Querying.

Alias for #key?.

Each argument other_hash in other_hashes must be a hash.

With arguments other_hashes given and no block, returns the new hash formed by merging each successive other_hash into a copy of self; returns that copy; for each successive entry in other_hash:

• For a new key, the entry is added at the end of self.

• For duplicate key, the entry overwrites the entry in self, whose position is unchanged.

Example:

h = {foo: 0, bar: 1, baz: 2}
h1 = {bat: 3, bar: 4}
h2 = {bam: 5, bat:6}
h.merge(h1, h2) # => {foo: 0, bar: 4, baz: 2, bat: 6, bam: 5}

With arguments other_hashes and a block given, behaves as above except that for a duplicate key the overwriting entry takes it value not from the entry in other_hash, but instead from the block:

• The block is called with the duplicate key and the values from both self and other_hash.

• The block’s return value becomes the new value for the entry in self.

Example:

h = {foo: 0, bar: 1, baz: 2}
h1 = {bat: 3, bar: 4}
h2 = {bam: 5, bat:6}
h.merge(h1, h2) { |key, old_value, new_value| old_value + new_value }
# => {foo: 0, bar: 5, baz: 2, bat: 9, bam: 5}

With no arguments, returns a copy of self; the block, if given, is ignored.

Related: see Methods for Assigning.

Updates values and/or adds entries to self; returns self.

Each argument other_hash in other_hashes must be a hash.

With no block given, for each successive entry key+/+new_value in each successive other_hash:

• If #key is in self, sets self[key] = new_value, whose position is unchanged:

  h0 = {foo: 0, bar: 1, baz: 2}
  h1 = {bar: 3, foo: -1}
  h0.update(h1) # => {foo: -1, bar: 3, baz: 2}

• If #key is not in self, adds the entry at the end of self:

  h = {foo: 0, bar: 1, baz: 2}
  h.update({bam: 3, bah: 4}) # => {foo: 0, bar: 1, baz: 2, bam: 3, bah: 4}

With a block given, for each successive entry key+/+new_value in each successive other_hash:

• If #key is in self, fetches old_value from self[key], calls the block with #key, old_value, and new_value, and sets self[key] = new_value, whose position is unchanged :

  season = {AB: 75, H: 20, HR: 3, SO: 17, W: 11, HBP: 3}
  today = {AB: 3, H: 1, W: 1}
  yesterday = {AB: 4, H: 2, HR: 1}
  season.update(yesterday, today) {|key, old_value, new_value| old_value + new_value }
  # => {AB: 82, H: 23, HR: 4, SO: 17, W: 12, HBP: 3}

• If #key is not in self, adds the entry at the end of self:

  h = {foo: 0, bar: 1, baz: 2}
  h.update({bat: 3}) { fail 'Cannot happen' }
  # => {foo: 0, bar: 1, baz: 2, bat: 3}

Related: see Methods for Assigning.

Searches self for the first entry whose value is #== to the given value; see Entry Order.

If the entry is found, returns its key and value as a 2-element array; returns nil if not found:

h = {foo: 0, bar: 1, baz: 1}
h.rassoc(1) # => [:bar, 1]

Related: see Methods for Fetching.

Rebuilds the hash table for self by recomputing the hash index for each key; returns self. Calling this method ensures that the hash table is valid.

The hash table becomes invalid if the hash value of a key has changed after the entry was created. See Modifying an Active Hash Key.

With a block given, returns a copy of self with zero or more entries removed; calls the block with each key-value pair; excludes the entry in the copy if the block returns a truthy value, includes it otherwise:

h = {foo: 0, bar: 1, baz: 2}
h.reject {|key, value| key.start_with?('b') }
# => {foo: 0}

With no block given, returns a new ::Enumerator.

Related: see Methods for Deleting.

With a block given, calls the block with each entry’s key and value; removes the entry from self if the block returns a truthy value.

Return self if any entries were removed, nil otherwise:

h = {foo: 0, bar: 1, baz: 2}
h.reject! {|key, value| value < 2 } # => {baz: 2}
h.reject! {|key, value| value < 2 } # => nil

With no block given, returns a new ::Enumerator.

Related: see Methods for Deleting.

Replaces the entire contents of self with the contents of other_hash; returns self:

h = {foo: 0, bar: 1, baz: 2}
h.replace({bat: 3, bam: 4}) # => {bat: 3, bam: 4}

Also replaces the default value or proc of self with the default value or proc of other_hash.

h = {}
other = Hash.new(:ok)
h.replace(other)
h.default # => :ok

Related: see Methods for Assigning.

Alias for #filter.

Alias for #filter!.

Removes and returns the first entry of self as a 2-element array; see Entry Order:

h = {foo: 0, bar: 1, baz: 2}
h.shift # => [:foo, 0]
h       # => {bar: 1, baz: 2}

Returns nil if self is empty.

Related: see Methods for Deleting.

Alias for #length.

Returns a new hash containing the entries from self for the given #keys; ignores any keys that are not found:

h = {foo: 0, bar: 1, baz: 2}
h.slice(:baz, :foo, :nosuch) # => {baz: 2, foo: 0}

Related: see Methods for Deleting.

Alias for #[]=.

Returns all elements of self as an array of 2-element arrays; each nested array contains a key-value pair from self:

h = {foo: 0, bar: 1, baz: 2}
h.to_a # => [[:foo, 0], [:bar, 1], [:baz, 2]]

Related: see Methods for Converting.

With a block given, returns a new hash whose content is based on the block; the block is called with each entry’s key and value; the block should return a 2-element array containing the key and value to be included in the returned array:

h = {foo: 0, bar: 1, baz: 2}
h.to_h {|key, value| [value, key] }
# => {0 => :foo, 1 => :bar, 2 => :baz}

With no block given, returns self if self is an instance of Hash; if self is a subclass of Hash, returns a new hash containing the content of self.

Related: see Methods for Converting.

Returns self.

Related: see Methods for Converting.

Returns a ::Proc object that maps a key to its value:

h = {foo: 0, bar: 1, baz: 2}
proc = h.to_proc
proc.class # => Proc
proc.call(:foo) # => 0
proc.call(:bar) # => 1
proc.call(:nosuch) # => nil

Related: see Methods for Converting.

Returns a new string containing the hash entries:

h = {foo: 0, bar: 1, baz: 2}
h.inspect # => "{foo: 0, bar: 1, baz: 2}"

Related: see Methods for Converting.

With an argument, a block, or both given, derives a new hash new_hash from self, the argument, and/or the block; all, some, or none of its keys may be different from those in self.

With a block given and no argument, new_hash has keys determined only by the block.

For each key/value pair old_key/value in self, calls the block with old_key; the block’s return value becomes new_key; sets new_hash[new_key] = value; a duplicate key overwrites:

h = {foo: 0, bar: 1, baz: 2}
h.transform_keys {|old_key| old_key.to_s }
# => {"foo" => 0, "bar" => 1, "baz" => 2}
h.transform_keys {|old_key| 'xxx' }
# => {"xxx" => 2}

With argument other_hash given and no block, new_hash may have new keys provided by other_hash and unchanged keys provided by self.

For each key/value pair old_key/old_value in self, looks for key old_key in other_hash:

• If old_key is found, its value other_hash[old_key] is taken as new_key; sets new_hash[new_key] = value; a duplicate key overwrites:

  h = {foo: 0, bar: 1, baz: 2}
  h.transform_keys(baz: :BAZ, bar: :BAR, foo: :FOO)
  # => {FOO: 0, BAR: 1, BAZ: 2}
  h.transform_keys(baz: :FOO, bar: :FOO, foo: :FOO)
  # => {FOO: 2}

• If old_key is not found, sets new_hash[old_key] = value; a duplicate key overwrites:

  h = {foo: 0, bar: 1, baz: 2}
  h.transform_keys({})
  # => {foo: 0, bar: 1, baz: 2}
  h.transform_keys(baz: :foo)
  # => {foo: 2, bar: 1}

Unused keys in other_hash are ignored:

h = {foo: 0, bar: 1, baz: 2}
h.transform_keys(bat: 3)
# => {foo: 0, bar: 1, baz: 2}

With both argument other_hash and a block given, new_hash has new keys specified by other_hash or by the block, and unchanged keys provided by self.

For each pair old_key and value in self:

• If other_hash has key old_key (with value new_key), does not call the block for that key; sets new_hash[new_key] = value; a duplicate key overwrites:

  h = {foo: 0, bar: 1, baz: 2}
  h.transform_keys(baz: :BAZ, bar: :BAR, foo: :FOO) {|key| fail 'Not called' }
  # => {FOO: 0, BAR: 1, BAZ: 2}

• If other_hash does not have key old_key, calls the block with old_key and takes its return value as new_key; sets new_hash[new_key] = value; a duplicate key overwrites:

  h = {foo: 0, bar: 1, baz: 2}
  h.transform_keys(baz: :BAZ) {|key| key.to_s.reverse }
  # => {"oof" => 0, "rab" => 1, BAZ: 2}
  h.transform_keys(baz: :BAZ) {|key| 'ook' }
  # => {"ook" => 1, BAZ: 2}

With no argument and no block given, returns a new ::Enumerator.

Related: see Methods for Transforming Keys and Values.

With an argument, a block, or both given, derives keys from the argument, the block, and self; all, some, or none of the keys in self may be changed.

With a block given and no argument, derives keys only from the block; all, some, or none of the keys in self may be changed.

For each key/value pair old_key/value in self, calls the block with old_key; the block’s return value becomes new_key; removes the entry for old_key: self.delete(old_key); sets self[new_key] = value; a duplicate key overwrites:

h = {foo: 0, bar: 1, baz: 2}
h.transform_keys! {|old_key| old_key.to_s }
# => {"foo" => 0, "bar" => 1, "baz" => 2}
h = {foo: 0, bar: 1, baz: 2}
h.transform_keys! {|old_key| 'xxx' }
# => {"xxx" => 2}

With argument other_hash given and no block, derives keys for self from other_hash and self; all, some, or none of the keys in self may be changed.

For each key/value pair old_key/old_value in self, looks for key old_key in other_hash:

• If old_key is found, takes value other_hash[old_key] as new_key; removes the entry for old_key: self.delete(old_key); sets self[new_key] = value; a duplicate key overwrites:

  h = {foo: 0, bar: 1, baz: 2}
  h.transform_keys!(baz: :BAZ, bar: :BAR, foo: :FOO)
  # => {FOO: 0, BAR: 1, BAZ: 2}
  h = {foo: 0, bar: 1, baz: 2}
  h.transform_keys!(baz: :FOO, bar: :FOO, foo: :FOO)
  # => {FOO: 2}

• If old_key is not found, does nothing:

  h = {foo: 0, bar: 1, baz: 2}
  h.transform_keys!({})
  # => {foo: 0, bar: 1, baz: 2}
  h.transform_keys!(baz: :foo)
  # => {foo: 2, bar: 1}

Unused keys in other_hash are ignored:

h = {foo: 0, bar: 1, baz: 2}
h.transform_keys!(bat: 3)
# => {foo: 0, bar: 1, baz: 2}

With both argument other_hash and a block given, derives keys from other_hash, the block, and self; all, some, or none of the keys in self may be changed.

For each pair old_key and value in self:

• If other_hash has key old_key (with value new_key), does not call the block for that key; removes the entry for old_key: self.delete(old_key); sets self[new_key] = value; a duplicate key overwrites:

  h = {foo: 0, bar: 1, baz: 2}
  h.transform_keys!(baz: :BAZ, bar: :BAR, foo: :FOO) {|key| fail 'Not called' }
  # => {FOO: 0, BAR: 1, BAZ: 2}

• If other_hash does not have key old_key, calls the block with old_key and takes its return value as new_key; removes the entry for old_key: self.delete(old_key); sets self[new_key] = value; a duplicate key overwrites:

  h = {foo: 0, bar: 1, baz: 2}
  h.transform_keys!(baz: :BAZ) {|key| key.to_s.reverse }
  # => {"oof" => 0, "rab" => 1, BAZ: 2}
  h = {foo: 0, bar: 1, baz: 2}
  h.transform_keys!(baz: :BAZ) {|key| 'ook' }
  # => {"ook" => 1, BAZ: 2}

With no argument and no block given, returns a new ::Enumerator.

Related: see Methods for Transforming Keys and Values.

With a block given, returns a new hash new_hash; for each pair key+/+value in self, calls the block with value and captures its return as new_value; adds to new_hash the entry key+/+new_value:

h = {foo: 0, bar: 1, baz: 2}
h1 = h.transform_values {|value| value * 100}
h1 # => {foo: 0, bar: 100, baz: 200}

With no block given, returns a new ::Enumerator.

Related: see Methods for Transforming Keys and Values.

With a block given, changes the values of self as determined by the block; returns self.

For each entry key+/+old_value in self, calls the block with old_value, captures its return value as new_value, and sets self[key] = new_value:

h = {foo: 0, bar: 1, baz: 2}
h.transform_values! {|value| value * 100} # => {foo: 0, bar: 100, baz: 200}

With no block given, returns a new ::Enumerator.

Related: see Methods for Transforming Keys and Values.

Alias for #merge!.

Returns whether value is a value in self.

Related: Methods for Querying.

Returns a new array containing all values in self:

h = {foo: 0, bar: 1, baz: 2}
h.values # => [0, 1, 2]

Related: see Methods for Fetching.

Returns a new array containing values for the given #keys:

h = {foo: 0, bar: 1, baz: 2}
h.values_at(:baz, :foo) # => [2, 0]

The hash default is returned for each key that is not found:

h.values_at(:hello, :foo) # => [nil, 0]

Related: see Methods for Fetching.