Array

A Ruby array is a list that grows as we add elements. The runtime handles the low-level details, so we can write clearer and more bug-free programs.

To create a Ruby array, we use the Array class. We can omit "Array" and just use the initializer. Or we can assign each element as we go along.

New Array

We first construct a new array with 4 integer elements. Then we modify the first element (at index 0). We display the array values. They are stored in the specified order.

# An array of integers.
values = Array[10, 20, 30, 40]

# Modify the first element.
values[0] = 100

# Display the array.
puts values
100
20
30
40

First, last

There is always a beginning and an end. This is true in an array where at least one element exists. First and last are helpful methods.

elements = ["ruby", "diamond", "gold"]

# First is the 0 index.
puts elements.first
puts elements[0]

# Last index is length minus one.
puts elements.last
puts elements[elements.length - 1]
ruby
ruby
gold
gold

Push

This method adds the specified element value to the end of the array. This is possible with a mutable collection. Here we start with an empty array.

# Create an empty array.
values = Array[]

# Push two elements.
values.push("tree")
values.push("grass")

# Print elements.
print "First: ", values.first, "\n"
print "Last:  ", values.last, "\n"
First: tree
Last:  grass

Push, operator

This is an alternative to the push method. It does the same thing but requires less source code. This operator can be chained—many elements can be added in one statement.

items = Array[]
# Append two strings, one after another.
items << "cat" << "dog"
# Append another element.
items << "bird"

p items
["cat", "dog", "bird"]

Delete

An array element can be deleted. When this occurs, the slot in the array is eliminated. Elements that come after are shifted forward.

# Citrus fruits.
arr = Array["orange", "lemon", "lime"]

# Delete element at index 1.
arr.delete_at(1)
puts "Fruit:", arr

# Delete element with value of "lime".
arr.delete("lime")
puts "Fruit:", arr
Fruit:
orange
lime
Fruit:
orange

Delete_if

This method receives a block that evaluates to true or false. The block is tested against each element in the array. If it evaluates to true, the element is deleted.

# An array of integers.
numbers = [10, 20, 30, 40, 50]

# Delete numbers greater than or equal to 40.
numbers.delete_if {|e| e >= 40}
puts numbers
10
20
30

Pop, empty

The pop method deletes the final element in an array. It simplifies the syntax for this operation. Empty(), also shown, returns true if an array has zero elements.

# Create and display an array.
names = Array["Conrad", "James", "Joyce"]
puts names, ""

# Pop the last element.
names.pop()
puts names, ""

# Pop again.
names.pop()
puts names, ""

# Pop again and see if the array is empty.
names.pop()
puts names.empty?
Conrad   3 elements
James
Joyce

Conrad   2 elements
James

Conrad   1 element

true     0 elements

Each

Any loop can iterate over an array. But some methods, called iterators, make looping over an array more elegant. They reduce complexity. They reduce possible errors.

# Some Wagstaff primes.
primes = [3, 11, 43, 683, 2731]

# Loop over primes and display them.
primes.each do |number|
    puts number
end
3
11
43
683
2731

Each, short syntax

Ruby is known for its expressive, glittering syntax. Here we use a short syntax form to write an iterator on one line.

# Some even numbers.
# ... Let's get even.
evens = [2, 4, 6, 8]

# Use short syntax form for the iterator block.
evens.each {|ev| puts ev}
2
4
6
8

Each_index

Sometimes we want to access all indexes in an array. This can be done with a loop, but the each_index iterator is also available. It yields all the indexes of the array.

# Array has indexes 0, 1 and 2.
values = ["cat", "dog", "sheep"]

# Loop over all indexes in the array.
values.each_index do |index|
    puts index
end
0
1
2

Index

This searches an array for the specified element. It starts its search at the beginning and proceeds to the following elements. If it finds the element, it returns its index value.

items = ["Boots", "Cloak", "Dagger"]

# Get index of this element.
result = items.index("Cloak")
puts result

# Call index again.
result = items.index("Dagger")
puts result

# Call index with nonexistent element.
result = items.index("Helmet")
if result == nil
    puts "Not found"
end
1
2
Not found

For-loop

In the range of the for-loop, we can specify an array slowest and highest indexes. To loop over the entire array, we specify the highest valid index as the maximum of the range.

# An array with four strings.
values = ["cat", "dog", "rabbit", "giraffe"]

# Loop over all indexes in the array.
for i in 0..values.length-1
    # Access the element.
    puts values[i]
end
cat
dog
rabbit
giraffe

Uniq

This removes all duplicate elements. We also can use the "uniq!" method to modify the array in-place. In this example, we call uniq to eliminate two duplicate element (a 1 and 4).

# Contains some duplicate elements.
values = [1, 1, 2, 3, 4, 4]

# Remove non-unique elements in-place.
values.uniq!
puts values
1
2
3
4

Collect

This applies (maps) each element in an array to a new value based on a function. For example we can multiply each element by two. With "collect!" the array is modified in-place.

# Contains three elements.
elements = [1, 0, 100]

# Use collect to multiply all elements by 2.
result = elements.collect{|e| e * 2}

# Display the result array.
p result
[2, 0, 200]

Ranges

With range syntax we can change parts of arrays in single operations. So we can replace a range of elements with a series of new elements. We can insert ranges this way.

elements = [10, 20, 30, 40, 50]

# Assign range of elements at indexes 1, 2, and 3 to a new array.
elements[1..3] = [100, 200]
puts elements
10
100
200
50

Sort, reverse

Arrays have sort() and reverse() methods. With sort, we can specify a block to sort elements by a method. In this way we implement ascending and descending sort orders.

values = [10, 0, 5]
# Use sort! and reverse! to modify the array in-place.
values.sort!
p values
values.reverse!
p values
[0, 5, 10]
[10, 5, 0]

Include

The "contains" method on arrays is called "include?" in Ruby. This method returns true or false (it is a predicate method).

Copy

How can we copy an array? The slice syntax is helpful here—we take a total-array slice, and this returns (with little hassle) a copied array.

Ruby arrays are powerful: they are resizable, and can be searched. As a result, they are used in many Ruby programs, forming the basis of other classes and collections.