Welcome! In this lesson, we’ll explore creating a simple address book application using Ruby hashes. This exercise will strengthen your understanding of hashes in Ruby, specifically in adding, retrieving, and deleting entries.

By the end of this lesson, you’ll have a solid grasp of these fundamental operations and how they’re applied in practical programming tasks.

In this task, we’ll build three core methods to manage our address book:

1. add_contact(name, phone_number): Adds a new contact. If the contact already exists, it returns false and does not overwrite the number; otherwise, it adds the contact and returns true.
2. get_contact(name): Retrieves the phone number for a given name. If the contact does not exist, it returns nil.
3. delete_contact(name): Deletes a contact with the specified name. Returns true if the contact was successfully deleted and false if the contact does not exist.

Let’s walk through each method in detail.

This method will add a new contact with the given name and phone_number. If the contact already exists, it returns false; otherwise, it adds the contact and returns true.

Question: Why is it important to check if a contact already exists before adding?

Answer: To avoid duplicating contacts and prevent overwriting existing information, which can lead to data inconsistency.

Here’s how we implement this method:

In this method:

• We check if the contact already exists with if @contacts.key?(name).
• If it exists, we return false.
• If it doesn’t exist, we add it to the hash and return true.

This method retrieves the phone number associated with a specified name. If the contact doesn’t exist, it returns nil.

Question: Why return nil when a contact isn’t found?

Answer: Returning nil provides a clear indication that the contact isn’t in the address book, allowing for smooth error handling.

Here’s the implementation:

In this method:

• We access the phone number with @contacts[name].
• If the name doesn’t exist, it returns nil. There is no need to explicitly return nil as Ruby automatically handles it when a hash key is not found.

This method deletes a contact by name. It returns true if the contact was deleted and false if the contact didn’t exist.

Question: What could happen if we try to delete a contact without checking if it exists?

Answer: Deleting a nonexistent contact might lead to errors or unintended behavior.

Here’s the method:

This concludes our implementation!

Below are some examples demonstrating how to use the methods in the AddressBook class:

These examples show how to interact with the AddressBook methods, from adding and retrieving contacts to deleting them, providing a complete overview of the class functionality.

Hashes offer several advantages for managing an address book:

• Efficient Lookups: Hashes provide average O(1) time complexity for lookups, making retrieving contacts by name very fast.
• Uniqueness: Hashes inherently ensure that each key (contact name) is unique, simplifying data consistency.
• Readability: The syntax for accessing hash entries is intuitive, making the code easier to understand and maintain.
• Flexibility: Ruby hashes are versatile, allowing us to extend the address book to store additional information, such as email addresses or addresses, if needed in the future.
• Handling Collisions: Although hash functions may generate the same hash for different keys, Ruby handles these collisions efficiently and ensures consistent performance. This is crucial for maintaining the integrity of our address book entries.

These features make Ruby hashes an ideal choice for implementing an address book.

In this lesson, we built a simple address book application using Ruby hashes. We implemented methods to add, retrieve, and delete contacts and discussed the benefits of using hashes for these operations.

You now have a practical understanding of how hashes work in Ruby and how to leverage them for efficient data management. Happy coding!