Hashes in Ruby

hashes.md

What's a Hash and why is it important?

A Hash is a collection of key-value pairs. To add, fetch, modify, and delete a value from a Hash, you refer to it with a unique key.

While an Array is indexed by Integers only, a Hash is keyed by any object -- Strings, Integers, etc.

In other programming languages, a Hash might be known as an 'associative array', 'dictionary', or 'HashMap'.

What does a Hash look like?

The empty Hash is just two curly braces:

{}

To create a Hash with a single key-value pair, place the pair inside the curly braces, separated by a hash-rocket =>:

{ 'name' => 'john' }

In this example, 'name' is the key and 'john' is the corresponding value.

NOTE: One space after the opening curly brace {, before the closing curly brace }, and around the hash-rocket => is considered good style.

Multiple key-value pairs are further separated by a comma and a space:

{ 'name' => 'john', 'age' => 40 }

In this example, 'name' and 'age' are the keys. And 'john' and 40 are their corresponding values.

When calling puts on a Hash:

puts 'name' => 'john', 'age' => 40

NOTE: Ruby will fail with a SyntaxError if you use curly braces {}.

It displays the following:

{"name"=>"john", "age"=>40}

NOTE: Ruby always uses double quotation marks when displaying Strings.

Similarly, when calling p on this Hash:

p 'name' => 'john', 'age' => 40

NOTE: Again, Ruby will fail with a SyntaxError if you use curly braces {}.

It also displays the following:

{"name"=>"john", "age"=>40}

How does a Hash compare to an Array?

A Hash and an Array have many commonalities. For example, an Array can be assigned to a variable:

person = ['john', 40]

Similarly, a Hash can be assigned to a variable too:

person = { 'name' => 'john', 'age' => 40 }

An Array can receive a variety of methods:

person = ['john', 40]
person.size  #=> 2

In this example, an Array with two elements is assigned to the person variable.

Similarly, a Hash can receive a variety of methods too:

person = { 'name' => 'john', 'age' => 40 }
person.size  #=> 2

In this example, a Hash with two key-value pairs is assigned to the person variable.

Fetching from a container

A single element of an Array can be fetched by it's index:

person = ['john', 40]
person[0]  #=> 'john'

Likewise, a single value of a Hash can be fetched by it's key:

person = { 'name' => 'john', 'age' => 40 }
person['name']  #=> 'john'

Fetching an element from an Array with a non-existent index returns nil:

person = ['john', 40]
person[2]  #=> nil

Likewise, fetching a value from a Hash with a non-existent key also returns nil:

person = { 'name' => 'john', 'age' => 40 }
person['location']  #=> nil

Modifying a container

Given an Array index, it's element can be reassigned:

person = ['john', 40]
person[0] = 'paul'

Likewise, given a Hash key, it's value can be reassigned:

person = { 'name' => 'john', 'age' => 40 }
person['name'] = 'paul'

Deleting from a container

Given an Array index, it's element can be deleted from the Array:

person = ['john', 40]
person.delete_at(0)  #=> 'john'
person  #=> [40]

NOTE: The element 40 is now at index 0.

Likewise, given a Hash key, it's key-value pair can be deleted:

person = { 'name' => 'john', 'age' => 40 }
person.delete('name')  #=> 'john'
person  #=> { 'age' => 40 }

NOTE: The value 40 is still at key 'age'.

Iterating over a container

Each element and index combination of an Array can be iterated over:

person = ['john', 40]

person.each_with_index do |element, index|
  puts "#{element} at #{index}"
end

Which displays the following:

john at 0
40 at 1

Similarly, each key-value pair of a Hash can be iterated over:

person = { 'name' => 'john', 'age' => 40 }

person.each do |key, value|
  puts "#{key}: #{value}"
end

Which displays the following:

name: john
age: 40

How does a Hash contrast to an Array?

Even with some minor quirks, Hashes and Arrays are rather similar. However, there are a few major differences.

Index Type vs Key Type

An Array is indexed by Integers only:

person = ['john', 40]
person[0]  #=> 'john'
person[1]  #=> 40

While a Hash is keyed by any object. For example, by Strings:

person = { 'name' => 'john', 'age' => 40 }
person['name']  #=> 'john'
person['age']   #=> 40

Or by Integers:

person = { 1 => 'john', 2 => 40 }
person[1]  #=> 'john'
person[2]  #=> 40

Or by a mixture of both Strings and Integers:

person = { 'name' => 'john', 2 => 40 }
person['name']  #=> 'john'
person[2]       #=> 40

Though it's rarely done, a Hash can even be keyed by an Array or a Hash.

NOTE: It's extremely common for a Hash to be keyed by a Symbol -- another object type you'll see shortly.

Index Order vs Value Order

An Array is ordered by the numerical value of each index, which always starts at 0:

person = ['john', 40]

person.each_with_index do |element, index|
  puts "#{element} at #{index}"
end

Which displays the following:

john at 0
40 at 1

On the other hand, a Hash is ordered by the insertion order of each the key-value pair:

person = { 'name' => 'john', 'age' => 40 }

person.each do |key, value|
  puts "#{key}: #{value}"
end

Which displays the following:

name: john
age: 40

Adding an Element vs Adding a Key-Value Pair

There are a variety of ways to add an element to an Array.

It can be pushed to the end of an Array by using either the push method or shovel << operator:

person = ['john', 40]
person.push('paul')  #=> ['john', 40, 'paul']
person << 72         #=> ['john', 40, 'paul', 72]

It can be unshifted to the beginning of an Array by using the unshift method:

person = ['john', 40]
person.unshift('paul')  #=> ['paul', 'john', 40]

And it can be inserted at a specific index of the Array with the insert method:

person = ['john', 40]
person.insert(1, 'paul')  #=> ['john', 'paul', 40]

All of these techniques make it easy for you to manage the order of the elements in an Array.

On the other hand, there is only one way to add a key-value pair to a Hash. And that is with the assignment = operator:

person = { 'name' => 'john', 'age' => 40 }
person['friend'] = 'paul'
person  #=> { 'name' => 'john', 'age' => 40, 'friend' => 'paul' }

In this example, the value 'paul' was assigned to the 'friend' key. Since the 'friend' key didn't exist in the Hash, the key-value pair was then added to the end.

Concatenation Arrays vs Merging Hashes

Two Arrays can be concatenated together, forming a new Array containing all the elements of both Arrays:

person = ['john'] + [40]
person  #=> ['john', 40]

However, two Hashes cannot be concatenated together:

person = { 'name' => 'john' } + { 'age' => 40 }
# NoMethodError: undefined method `+' for {"name"=>"john"}:Hash

Instead, two Hashes can be merged together:

person = { 'name' => 'john' }.merge('age' => 40)
person  #=> { 'name' => 'john', 'age' => 40 }

NOTE: A Hash used as a method argument does not need the curly braces {}.

At first glace, merging looks just like concatenation. However, when both Hashes have the same key, the Hash inside the merge method takes precedence:

person = { 'name' => 'john', 'age' => 40 }.merge('age' => 35)
person  #=> { 'name' => 'john', 'age' => 35 }

In this example, both Hashes contain the 'age' key. When merged together, the 'age' => 35 key-value pair overwrites the 'age' => 40 key-value pair. In other words, key-value pairs from the Hash inside the merge method overwrite key-value pairs from the Hash receiving the method call.

What confusion i have had--its all gone now!!! ):