Zips two arrays into a Hash, taking keys from ary1 and values from ary2.

Hash.zip(["key1", "key2", "key3"], ["value1", "value2", "value3"])
# => {"key1" => "value1", "key2" => "value2", "key3" => "value3"}

Compares with other. Returns true if all key-value pairs are the same.

See also: Hash#fetch.

Sets the value of key to the given value.

h = {} of String => String
h["foo"] = "bar"
h["foo"] # => "bar"

Returns the value for the key given by key. If not found, returns nil. This ignores the default value set by Hash.new.

h = {"foo" => "bar"}
h["foo"]? # => "bar"
h["bar"]? # => nil

h = Hash(String, String).new("bar")
h["foo"]? # => nil

Empties a Hash and returns it.

hash = {"foo" => "bar"}
hash.clear # => {}

Similar to #dup, but duplicates the values as well.

hash_a = {"foobar" => {"foo" => "bar"}}
hash_b = hash_a.clone
hash_b["foobar"]["foo"] = "baz"
hash_a # => {"foobar" => {"foo" => "bar"}}

Returns new Hash without nil values.

hash = {"hello" => "world", "foo" => nil}
hash.compact # => {"hello" => "world"}

Removes all nil value from self. Returns nil if no changes were made.

hash = {"hello" => "world", "foo" => nil}
hash.compact! # => {"hello" => "world"}
hash.compact! # => nil

Deletes the key-value pair and returns the value, otherwise returns nil.

h = {"foo" => "bar"}
h.delete("foo")     # => "bar"
h.fetch("foo", nil) # => nil

Deletes the key-value pair and returns the value, else yields key with given block.

h = {"foo" => "bar"}
h.delete("foo") { |key| "#{key} not found" } # => "bar"
h.fetch("foo", nil)                          # => nil
h.delete("baz") { |key| "#{key} not found" } # => "baz not found"

Deletes each key-value pair for which the given block returns true.

h = {"foo" => "bar", "fob" => "baz", "bar" => "qux"}
h.delete_if { |key, value| key.starts_with?("fo") }
h # => { "bar" => "qux" }

Duplicates a Hash.

hash_a = {"foo" => "bar"}
hash_b = hash_a.dup
hash_b.merge!({"baz" => "qux"})
hash_a # => {"foo" => "bar"}

Returns an iterator over the hash entries. Which behaves like an Iterator returning a Tuple consisting of the key and value types.

hsh = {"foo" => "bar", "baz" => "qux"}
iterator = hsh.each

iterator.next # => {"foo", "bar"}
iterator.next # => {"baz", "qux"}

Calls the given block for each key-value pair and passes in the key and the value.

h = {"foo" => "bar"}

h.each do |key, value|
  key   # => "foo"
  value # => "bar"
end

h.each do |key_and_value|
  key_and_value # => {"foo", "bar"}
end

Returns an iterator over the hash keys. Which behaves like an Iterator consisting of the key's types.

hsh = {"foo" => "bar", "baz" => "qux"}
iterator = hsh.each_key

key = iterator.next
key # => "foo"

key = iterator.next
key # => "baz"

Calls the given block for each key-value pair and passes in the key.

h = {"foo" => "bar"}
h.each_key do |key|
  key # => "foo"
end

Calls the given block for each key-value pair and passes in the value.

h = {"foo" => "bar"}
h.each_value do |value|
  value # => "bar"
end

Returns an iterator over the hash values. Which behaves like an Iterator consisting of the value's types.

hsh = {"foo" => "bar", "baz" => "qux"}
iterator = hsh.each_value

value = iterator.next
value # => "bar"

value = iterator.next
value # => "qux"

Returns true when hash contains no key-value pairs.

h = Hash(String, String).new
h.empty? # => true

h = {"foo" => "bar"}
h.empty? # => false

Returns the value for the key given by key, or when not found calls the given block with the key.

h = {"foo" => "bar"}
h.fetch("foo") { |key| key.upcase } # => "bar"
h.fetch("bar") { |key| key.upcase } # => "BAR"

Returns the value for the key given by key, or when not found the value given by default. This ignores the default value set by Hash.new.

h = {"foo" => "bar"}
h.fetch("foo", "foo") # => "bar"
h.fetch("bar", "foo") # => "foo"

Returns the value for the key given by key. If not found, returns the default value given by Hash.new, otherwise raises KeyError.

h = {"foo" => "bar"}
h["foo"] # => "bar"

h = Hash(String, String).new("bar")
h["foo"] # => "bar"

h = Hash(String, String).new { "bar" }
h["foo"] # => "bar"

h = Hash(String, String).new
h["foo"] # raises KeyError

Returns the first key in the hash.

Returns the first key if it exists, or returns nil.

hash = {"foo" => "bar"}
hash.first_key? # => "foo"
hash.clear
hash.first_key? # => nil

Returns the first value in the hash.

Similar to #first_key?, but returns its value.

Returns true when key given by key exists, otherwise false.

h = {"foo" => "bar"}
h.has_key?("foo") # => true
h.has_key?("bar") # => false

Returns true when value given by value exists, otherwise false.

h = {"foo" => "bar"}
h.has_value?("foo") # => false
h.has_value?("bar") # => true

See also: Object#hash.

foo = {"foo" => "bar"}
foo.hash # => 3247054

Inverts keys and values. If there are duplicated values, the last key becomes the new value.

{"foo" => "bar"}.invert                 # => {"bar" => "foo"}
{"foo" => "bar", "baz" => "bar"}.invert # => {"bar" => "baz"}

Returns the first key with the given value, else raises KeyError.

hash = {"foo" => "bar", "baz" => "qux"}
hash.key("bar")    # => "foo"
hash.key("qux")    # => "baz"
hash.key("foobar") # raises KeyError (Missing hash key for value: foobar)

Returns the first key with the given value, else yields value with the given block.

hash = {"foo" => "bar"}
hash.key("bar") { |value| value.upcase } # => "foo"
hash.key("qux") { |value| value.upcase } # => "QUX"

Returns the first key with the given value, else nil.

hash = {"foo" => "bar", "baz" => "qux"}
hash.key?("bar")    # => "foo"
hash.key?("qux")    # => "baz"
hash.key?("foobar") # => nil

Returns the index of the given key, or nil when not found. The keys are ordered based on when they were inserted.

h = {"foo" => "bar", "baz" => "qux"}
h.key_index("foo") # => 0
h.key_index("qux") # => nil

Returns a new Array with all the keys.

h = {"foo" => "bar", "baz" => "bar"}
h.keys # => ["foo", "baz"]

Returns a new Hash with the keys and values of this hash and other combined. A value in other takes precedence over the one in this hash.

hash = {"foo" => "bar"}
hash.merge({"baz" => "qux"})
# => {"foo" => "bar", "baz" => "qux"}
hash
# => {"foo" => "bar"}

Similar to #merge, but the receiver is modified.

hash = {"foo" => "bar"}
hash.merge!({"baz" => "qux"})
hash # => {"foo" => "bar", "baz" => "qux"}

Returns a new Hash without the given keys.

{"a" => 1, "b" => 2, "c" => 3, "d" => 4}.reject("a", "c") # => {"b" => 2, "d" => 4}

Returns a new hash consisting of entries for which the block returns false.

h = {"a" => 100, "b" => 200, "c" => 300}
h.reject { |k, v| k > "a" } # => {"a" => 100}
h.reject { |k, v| v < 200 } # => {"b" => 200, "c" => 300}

Equivalent to Hash#reject, but makes modification on the current object rather that returning a new one. Returns nil if no changes were made.

Removes a list of keys out of hash.

h = {"a" => 1, "b" => 2, "c" => 3, "d" => 4}.reject!("a", "c")
h # => {"b" => 2, "d" => 4}

Returns a new hash consisting of entries for which the block returns true.

h = {"a" => 100, "b" => 200, "c" => 300}
h.select { |k, v| k > "a" } # => {"b" => 200, "c" => 300}
h.select { |k, v| v < 200 } # => {"a" => 100}

Returns a new Hash with the given keys.

{"a" => 1, "b" => 2, "c" => 3, "d" => 4}.select("a", "c") # => {"a" => 1, "c" => 3}

Equivalent to Hash#select but makes modification on the current object rather that returning a new one. Returns nil if no changes were made

Removes every element except the given ones.

h = {"a" => 1, "b" => 2, "c" => 3, "d" => 4}.select!("a", "c")
h # => {"a" => 1, "c" => 3}

Deletes and returns the first key-value pair in the hash. Yields to the given block if the hash is empty.

hash = {"foo" => "bar", "baz" => "qux"}
hash.shift { true } # => {"foo", "bar"}
hash                # => {"baz" => "qux"}

hash = {} of String => String
hash.shift { true } # => true
hash                # => {}

Deletes and returns the first key-value pair in the hash, or raises IndexError if the hash is empty.

hash = {"foo" => "bar", "baz" => "qux"}
hash.shift # => {"foo", "bar"}
hash       # => {"baz" => "qux"}

hash = {} of String => String
hash.shift # raises IndexError

Same as #shift, but returns nil if the hash is empty.

hash = {"foo" => "bar", "baz" => "qux"}
hash.shift? # => {"foo", "bar"}
hash        # => {"baz" => "qux"}

hash = {} of String => String
hash.shift? # => nil

Returns self.

Converts to a String.

h = {"foo" => "bar"}
h.to_s       # => "{\"foo\" => \"bar\"}"
h.to_s.class # => String

Returns only the values as an Array.

h = {"foo" => "bar", "baz" => "qux"}
h.values # => ["bar", "qux"]

Returns a tuple populated with the elements at the given indexes. Raises if any index is invalid.

{"a" => 1, "b" => 2, "c" => 3, "d" => 4}.values_at("a", "c") # => {1, 3}