class Hash

A Hash maps each of its unique keys to a specific value.

A Hash has certain similarities to an Array, but:

Hash Data Syntax ↑

The older syntax for Hash data uses the “hash rocket,” =>:

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

Alternatively, but only for a Hash key that’s a Symbol, you can use a newer JSON-style syntax, where each bareword becomes a Symbol:

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

You can also use a String in place of a bareword:

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

And you can mix the styles:

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

But it’s an error to try the JSON-style syntax for a key that’s not a bareword or a String:

# Raises SyntaxError (syntax error, unexpected ':', expecting =>):
h = {0: 'zero'}

Hash value can be omitted, meaning that value will be fetched from the context by the name of the key:

x = 0
y = 100
h = {x:, y:}
h # => {x: 0, y: 100}

Common Uses ↑

You can use a Hash to give names to objects:

person = {name: 'Matz', language: 'Ruby'}
person # => {name: "Matz", language: "Ruby"}

You can use a Hash to give names to method arguments:

def some_method(hash)
  p hash
end
some_method({foo: 0, bar: 1, baz: 2}) # => {foo: 0, bar: 1, baz: 2}

Note: when the last argument in a method call is a Hash, the curly braces may be omitted:

some_method(foo: 0, bar: 1, baz: 2) # => {foo: 0, bar: 1, baz: 2}

You can use a Hash to initialize an object:

class Dev
  attr_accessor :name, :language
  def initialize(hash)
    self.name = hash[:name]
    self.language = hash[:language]
  end
end
matz = Dev.new(name: 'Matz', language: 'Ruby')
matz # => #<Dev: @name="Matz", @language="Ruby">

Creating a Hash ↑

You can create a Hash object explicitly with:

You can convert certain objects to Hashes with:

You can create a Hash by calling method Hash.new.

Create an empty Hash:

h = Hash.new
h # => {}
h.class # => Hash

You can create a Hash by calling method Hash.[].

Create an empty Hash:

h = Hash[]
h # => {}

Create a Hash with initial entries:

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

You can create a Hash by using its literal form (curly braces).

Create an empty Hash:

h = {}
h # => {}

Create a Hash with initial entries:

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

Hash Value Basics ↑

The simplest way to retrieve a Hash value (instance method []):

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

The simplest way to create or update a Hash value (instance method []=):

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

The simplest way to delete a Hash entry (instance method delete):

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

Entry Order ↑

A Hash object presents its entries in the order of their creation. This is seen in:

A new Hash has its initial ordering per the given entries:

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

New entries are added at the end:

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

Updating a value does not affect the order:

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

But re-creating a deleted entry can affect the order:

h.delete(:foo)
h[:foo] = 5
h # => {bar: 1, baz: 3, foo: 5}

Hash Keys ↑

Hash Key Equivalence ↑

Two objects are treated as the same hash key when their hash value is identical and the two objects are eql? to each other.

Modifying an Active Hash Key ↑

Modifying a Hash key while it is in use damages the hash’s index.

This Hash has keys that are Arrays:

a0 = [ :foo, :bar ]
a1 = [ :baz, :bat ]
h = {a0 => 0, a1 => 1}
h.include?(a0) # => true
h[a0] # => 0
a0.hash # => 110002110

Modifying array element a0[0] changes its hash value:

a0[0] = :bam
a0.hash # => 1069447059

And damages the Hash index:

h.include?(a0) # => false
h[a0] # => nil

You can repair the hash index using method rehash:

h.rehash # => {[:bam, :bar]=>0, [:baz, :bat]=>1}
h.include?(a0) # => true
h[a0] # => 0

A String key is always safe. That’s because an unfrozen String passed as a key will be replaced by a duplicated and frozen String:

s = 'foo'
s.frozen? # => false
h = {s => 0}
first_key = h.keys.first
first_key.frozen? # => true

User-Defined Hash Keys ↑

To be usable as a Hash key, objects must implement the methods hash and eql?. Note: this requirement does not apply if the Hash uses compare_by_identity since comparison will then rely on the keys’ object id instead of hash and eql?.

Object defines basic implementation for hash and eq? that makes each object a distinct key. Typically, user-defined classes will want to override these methods to provide meaningful behavior, or for example inherit Struct that has useful definitions for these.

A typical implementation of hash is based on the object’s data while eql? is usually aliased to the overridden == method:

class Book
  attr_reader :author, :title

  def initialize(author, title)
    @author = author
    @title = title
  end

  def ==(other)
    self.class === other &&
      other.author == @author &&
      other.title == @title
  end

  alias eql? ==

  def hash
    [self.class, @author, @title].hash
  end
end

book1 = Book.new 'matz', 'Ruby in a Nutshell'
book2 = Book.new 'matz', 'Ruby in a Nutshell'

reviews = {}

reviews[book1] = 'Great reference!'
reviews[book2] = 'Nice and compact!'

reviews.length #=> 1

Key Not Found? ↑

When a method tries to retrieve and return the value for a key and that key is found, the returned value is the value associated with the key.

But what if the key is not found? In that case, certain methods will return a default value while other will raise a KeyError.

Nil Return Value ↑

If you want nil returned for a not-found key, you can call:

You can override these behaviors for [], dig, and values_at (but not assoc); see Hash Default.

KeyError ↑

If you want KeyError raised for a not-found key, you can call:

Hash Default ↑

For certain methods ([], dig, and values_at), the return value for a not-found key is determined by two hash properties:

In the simple case, both values are nil, and the methods return nil for a not-found key; see Nil Return Value above.

Note that this entire section (“Hash Default”):

Any-Key Default ↑

You can define an any-key default for a hash; that is, a value that will be returned for any not-found key:

You can set the default value when the hash is created with Hash.new and option default_value, or later with method default=.

Note: although the value of default may be any object, it may not be a good idea to use a mutable object.

Per-Key Defaults ↑

You can define a per-key default for a hash; that is, a Proc that will return a value based on the key itself.

You can set the default proc when the hash is created with Hash.new and a block, or later with method default_proc=.

Note that the proc can modify self, but modifying self in this way is not thread-safe; multiple threads can concurrently call into the default proc for the same key.

Method Default ↑

For two methods, you can specify a default value for a not-found key that has effect only for a single method call (and not for any subsequent calls):

What’s Here ↑

First, what’s elsewhere. Class Hash:

Here, class Hash provides methods that are useful for:

Class Hash also includes methods from module Enumerable.

Methods for Creating a Hash ↑

Methods for Setting Hash State ↑

Methods for Querying ↑

Methods for Comparing ↑

Methods for Fetching ↑

Methods for Assigning ↑

Methods for Deleting ↑

These methods remove entries from self:

These methods return a copy of self with some entries removed:

Methods for Iterating ↑

Methods for Converting ↑

Methods for Transforming Keys and Values ↑