In the previous chapter, we studied variables, constants, strings, and various data types. We performed various operations on strings and numbers. We were also introduced to the Interactive Ruby Shell (IRB), which makes coding in Ruby easier.

This chapter is dedicated to bringing you up to speed with arrays, hashes, and methods in Ruby. You could say that these are among the most fundamental topics. We will take a closer look at the different ways of creating arrays and hashes, as there are a wide variety of options. We'll also look at methods, which is another essential concept in Ruby and study certain rules about arguments that you should be aware of while creating methods. After that, you have the fundamentals to become a fine Ruby developer.

An array is a data structure that contains a list of values called elements. Arrays can be an ordered, integer-indexed collection of any object. Ruby arrays can have objects such as Integer, String, Symbol, Fixnum, and Hash, or even other arrays, as elements. In many languages, arrays are rigid in terms of their size. In Ruby, however, an array increases its size as elements are added.

When we say ordered, we mean that the array will keep track of how the elements are inserted or removed from it. While fetching the data from an array, we can retrieve the values directly based on the position of the element. This will become clearer as we dive into the depths of data extraction and manipulation using arrays.

Integer-indexed means that each element in the array is linked to an index. In Ruby, we can fetch the data from an array based on the index irrespective of the value at that location. Like most other languages, array indexes in Ruby start from zero.

Ruby is very...

Hashes are collections that save data as key-value pairs. This means that a key will identify every value that we want to save. This also means that keys within a hash have to be unique, otherwise we will overwrite the old values.

In terms of performance, hashes have a lookup time of O(1), which means that finding a value in a hash by its key will not be dependent on the size of the hash, nor on the order in which the hash was created. O(1) means a constant lookup time for the operation performed on a hash, irrespective of the data size. This differs from arrays, where finding a value in an O(n) operation means that the time taken to find an element in an array will be dependent on the length of an array. This means that we are looking for an element and we are going to find it on the nth location; the n does not denote the size of the array, but the location of the element.

An empty hash can be created as follows:

my_hash = {}
my_hash = Hash.new

The output will...

A method in Ruby is a set of expressions that return a value. These are similar to functions in other programming languages. Methods are defined using the def keyword, followed by the method name and then by optional parameters. The method body is enclosed between the preceding definition and the end keyword at the bottom:

def my_method
##method body
end

By convention, method names should begin with a lowercase letter, otherwise Ruby might consider it to be a constant while parsing. Also, names that have multiple words should be separated by an underscore. As in the preceding examples, the method name – my_method, has an underscore between two words.

Passing Arguments to a Method

We can pass arguments to the method on which a method has to operate. There is no limit in terms of the number of parameters that we can pass to a method. The following is a simple example of how we can create our own methods in Ruby:

def add_two_numbers a, b
  ...

In this chapter, we took a journey into data types and some very common operations that can be performed on them. We started out with array operations and took a closer look at adding, removing, and iterating over this data type. Then, we moved on to the hash data type and discovered the hidden magic that powers most of the web and desktop applications written in Ruby. Hashes are a very common way to store and manipulate data inside web applications. We added, removed, and iterated over hashes, and then performed some symbol-based sorting with nested hashes. Our final destination in this chapter was the methods and functions that allow us to create either functional or procedural applications in Ruby. Functions and methods in themselves are not of much use, so we imbued them with arguments. We also took a closer look at how optional and default arguments are handled in case multiple arguments are passed. This constituted a very important chapter, namely, how the extra arguments...