Ruby Hash

A Hash is a data structure in Ruby that stores key-value pairs. It's similar to an Array, but where an Array uses integers as its index, a Hash allows you to use any object type as an index.

1. Creating a Hash

You can create a Hash by using the literal constructor {}:

my_hash = {}

You can also use Hash.new to create a new Hash:

my_hash = Hash.new

2. Adding to a Hash

You can add elements to a Hash by using the []= operator:

my_hash = {}
my_hash["key"] = "value"

This creates a key-value pair in my_hash where "key" is the key and "value" is the value.

3. Accessing a Hash

You can access elements in a Hash by their key:

my_hash = {"key" => "value"}
puts my_hash["key"] # Outputs: value

4. Iterating Over a Hash

You can iterate over a Hash using methods like each, each_key, and each_value:

my_hash = {"key1" => "value1", "key2" => "value2"}

my_hash.each do |key, value|
  puts "The key is #{key} and the value is #{value}"
end

my_hash.each_key do |key|
  puts "Key: #{key}"
end

my_hash.each_value do |value|
  puts "Value: #{value}"
end

5. Deleting from a Hash

You can remove a key-value pair from a Hash using the delete method:

my_hash = {"key" => "value"}
my_hash.delete("key")

6. Merging Hashes

You can combine two hashes into one using the merge method:

hash1 = {"key1" => "value1"}
hash2 = {"key2" => "value2"}

merged_hash = hash1.merge(hash2) # {"key1" => "value1", "key2" => "value2"}

Note that if the hashes have keys that are the same, the value from the second hash will overwrite the value from the first hash.

7. Checking if a Key or Value Exists

You can check if a key or value exists in a Hash using the has_key? and has_value? methods:

my_hash = {"key" => "value"}

puts my_hash.has_key?("key")  # Outputs: true
puts my_hash.has_value?("value")  # Outputs: true

These are the basics of using Hashes in Ruby. Hashes are a very powerful and flexible data structure that can be used to represent complex data relationships in your programs.

Creating a Hash in Ruby:

# Using literal notation
my_hash = { key1: 'value1', key2: 'value2' }

# Using the Hash.new constructor
another_hash = Hash.new
another_hash[:name] = 'John'

Accessing values in a Ruby Hash:

my_hash[:key1]  # Accessing value using key

Updating values in a Ruby Hash:

my_hash[:key1] = 'new_value'  # Updating value for an existing key

Ruby Hash iteration:

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

Merging Hashes in Ruby:

merged_hash = hash1.merge(hash2)  # Merging two hashes

Deleting entries from a Ruby Hash:

my_hash.delete(:key1)  # Deleting entry by key

Sorting a Hash in Ruby:

sorted_hash = my_hash.sort.to_h  # Sorting by keys

Default values in Ruby Hash:

my_hash = Hash.new('default_value')  # Setting a default value

Nested Hashes in Ruby:

nested_hash = { outer_key: { inner_key: 'value' } }

Converting a Hash to an array in Ruby:

array_from_hash = my_hash.to_a  # Convert hash to array of key-value pairs

Comparing Hashes in Ruby:

hash1 == hash2  # Comparing equality of two hashes

Immutable Hashes in Ruby: Ruby Hashes are mutable by default, but you can achieve immutability using freeze:
```
my_immutable_hash = { key: 'value' }.freeze
```