Arrays in Ruby

Let’s start this post creating an array in Ruby (notice we are using the irb environment for our examples):

>> array=["a","b","c","d"]
=> ["a", "b", "c", "d"]

You just put a list of items separated by commas between square brackets, assign it to a variable, and the array is created. In Ruby, the array indexes start at 0, so if you want to retrieve the first item from the array you just created, simply type:

>> array[0]
=> "a"

Let’s try to access an index out of range in the array.

>> array[4]
=> nil

You will get the nil object as return value.

You can retrieve several items at once using array[i,n] in which i is the starting index for the items you want, and n is the number of items you want.

>> array[2,2]
=> ["c", "d"]

You can make assignments to your array, replacing multiple items at once. Let’s start modifying the array we created above.

>> array[1,2]=["B","C"]
=> ["B", "C"]
>> array
=> ["a", "B", "C", "d"]

It’s possible to replace multiple items by a different number of items.

>> array[1,2]=["X","Y","Z"]
=> ["X", "Y", "Z"]
>> array
=> ["a", "X", "Y", "Z", "d"]

It’s also possible delete them using the same technique.

>> array[2,3]=[]
=> []
>> array
=> ["a", "X"]

You can even insert new elements between the other elements of the array using array[i,n] with n=0. Let’s create another array with symbols and insert one element between the others.

>> a=[:a,:b,:d,:e]
=> [:a, :b, :d, :e]
>> a[2,0]=[:c]
=> [:c]
>> a
=> [:a, :b, :c, :d, :e]

You can think that the array[i,n] syntax means: retrieve n elements from the array starting by the i-th position. If you try to access elements from the array using n=0, you will get [] as a result (within the range of the array).

>> a[1,0]
=> []

Actually, what is happening on the situation above, is that n=0 will define a place between elements of the array, just between the indexes i-1 and i.

For retrieving elements, you may see no reason to use array[i,n] with n=0. But, for inserting elements, it can be really useful. As you saw in the examples above, instead of replacing elements, you can insert new elements on the array using n=0. So, to insert a new element at the end of an array we can do the following:

>> b=[:x,:y]
=> [:x, :y]
>> b[2,0]=:z
=> :z
>> b
=> [:x, :y, :z]

Now, one interesting point to finish this article, observe the behaviours showed bellow:

>> b[3]
=> nil

In the example above the index 3 is out of range, since the array b has three elements.

>> b[3,0]
=> []

In the example showed above, we are on the tail of the array, so we’re not out of range yet.

>> b[4,0]
=> nil

Now we are out of the range, so we received a nil object as return value.