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.