Collections

Loop iteration

You can use the loops we learned in the last chapter – for or while – like so:

arr = [1,2,3,4,5,6]              
for x in 0..(arr.length-1)
    puts arr[x]
end

# or, with while:
x = 0
while x < arr.length
    puts arr[x]
    x += 1
end

However, as I briefly mentioned in the last chapter, most iteration in Ruby is done using the each method.

The each method provides a tighter syntax:

arr.each{ |x| puts x}        

# using the equivalent do..end construct:
arr.each do |x|
    puts x
end
          

The each method yields a reference to each element in the collection, rather than a reference to the element's numerical index in the array.

However, sometimes a reference to the current element's index is useful. Collections also have the each_with_index method available to them:

arr = ['cat', 'dog', 'pony', 'bird']
arr.each_with_index do |str, idx|
    puts "#{str} and #{arr[idx-1]} show"
end              

#=> cat and bird show
#=> dog and cat show
#=> pony and dog show
#=> bird and pony show
                

Adding to an Array with push

Collections can expand and contract. As arrays are their own data type, you can't use the + operator to add non-arrays and arrays together

# Attempting to add a Fixnum to an Array:
[3,2,1] + 4   # TypeError: can't convert Fixnum into Array

# Adding an array with one Fixnum to another Array:
[3,2,1] + [4]   # [3,2,1,4]
         

Note: Adding a new element to an array, as in the above example, will add it to the end of the left-side array. Arrays do not automatically sort themselves or maintain any kind of alphabetical/numerical order (but they do have methods for that).

It's a little clunky to put square brackets around a single object just to add it to an array. The push method (other languages also use the word push for this functionality) adds objects to the end of an array:

arr = ['dog', 'cat', 'bear']
arr.push('penguin', 'fox')

puts arr.join("-")   #=> dog-cat-bear-penguin-fox
puts arr[0]   # dog         
            

Unlike most of the methods we've covered so far, push modifies the array that calls it. A new element is added to that same array, rather than a new array. So there's no need to do the assignment operation in the second line here:

arr = ['dog', 'cat', 'bear']
arr.push('penguin', 'fox')
puts arr.join(',')   
#=> dog,cat,bear,penguin,fox
         

In Ruby, you can also use two left-angled brackets << to push objects onto an array:

new_arr = ["dog", 7, 42, "cat"]
new_arr << 42
puts new_arr.join(",")   
#=> dog,7,42,cat,42
      

Remove with pop

To take an item out of an array, use pop, which removes (and returns) the last item in the array.

Just as with push, pop operates at the end of the array. In computer science lingo, this is referred to as LIFO – Last In, First Out:

And, like push, pop also modifies its array.

arr = ["Atlanta", "Boston", "Chicago", 42]
arr.pop   # 42
puts arr.join(', ')   #=> Atlanta, Boston, Chicago
            

arr = [1,2,3,4,5]   # given an arbitrary array
      
temparr = []
for x in 0..(arr.length-1)   # or: arr.length.times
   temparr.push(arr.pop)
end
arr = temparr            
         

temparr = []
temparr.push( arr.pop) until arr.empty?   # alternatively: while !arr.empty?
arr = temparr            
                  

array[x] = array[final_index-x]

arr.length/2

arr = [1,2,3,4,5]   # given an arbitrary array
   
final_idx = arr.length-1
for x in 0..(arr.length/2)
   temp = arr[x]
   arr[x] = arr[final_idx - x]
   arr[final_idx - x] = temp
end

arr = [1,2,3,4,5]   # given an arbitrary array
   
final_idx = arr.length-1
for x in 0..(arr.length/2)
   arr[x], arr[final_idx - x] = arr[final_idx - x], arr[x]
end

Sorting arrays

As you insert elements into an Array, they will remain in the order in which they were added. You can call the sort or sort_by methods, both of which return a sorted copy of that an array.

The default sort

When your array contains a uniform set of standard objects, such as numbers or strings, calling sort without any arguments will arrange the array's elements in ascending order:

puts [8, 0, 15, -42].sort.join(', ')   #=> -42, 0, 8, 15

arr = ["cat", "zebra", "dog", "alpaca"]
puts arr.sort.join(', ')   #=> alpaca, cat, dog, zebra

              

[6, -30, 0, 100, 2].sort.reverse   #=> [100, 6, 2, 0, -30]      
              

Custom sorting with sort_by

Alphabetical letters of different cases do not sort alphabetically. Try converting a letter into a number to see the standard numerical code that represents it:

puts 'a'[0]   #=> 97
puts 'B'[0]   #=> 66
puts 'c'[0]   #=> 99
puts 'Z'[0]   #=> 90

puts ['a', 'B', 'c', 'Z'].sort.join(', ')   #=> B, Z, a, c
        

If we want to sort a collection's elements by values derived from the elements, we can use sort_by. This method takes in a block; the block's return value is what ends up being compared.

To sort strings in alphabetical order without regard to case, we pass a block into sort_by that either lowercases or uppercases each string for the comparison.

arr = ['Bob', 'Zed', 'cat', 'apple'].sort_by do |x|
   x.upcase
end

puts arr.join(', ')   #=> apple, Bob, cat, Zed
              

Note: Despite the upcase operation done in the block passed to sort_by, the elements in arr themselves are not modified during the sort.

String.split

There are also methods to convert other objects into arrays. One we'll use frequently is split from the String class, which turns a string into an array of elements, separated by a delimiter string you specify.

"Smith,John,Ithica,NY".split(',')   #=> ["Smith", "John", "Ithica", "NY"]      
"She sells seashells".split(' ')   #=> ['She', 'sells', 'seashells']
"She sells seashells".split('se')   #=> ["She ", "lls ", "ashells"]   
           

names = ["John Smith", "Dan Boone", "Jennifer Jane", "Charles Lindy", "Jennifer Eight", "Rob Roy"]

names = ["John Smith", "Dan Boone", "Jennifer Jane", "Charles Lindy", "Jennifer Eight", "Rob Roy"]
sorted_names = names.sort_by do |name|
   name.split(" ").reverse.join.upcase
end

puts sorted_names.join('; ')
#=> Dan Boone; Jennifer Eight; Jennifer Jane; Charles Lindy; Rob Roy; John Smith

sorted_names = names.sort_by{ |name| name.split(" ").reverse.join.upcase }

Comparing Hash and Array operations

Here's a table showing the common collection-type operations for arrays and hashes.

arr = []

hsh = {}

arr = [
      ["dog", "Fido"], 
      ["cat", "Whiskers"]
]

hsh = { 
   "dog"=>"Fido", 
   "cat"=>"Whiskers"
}  

arr << ["pig", "Wilbur"]

hsh["pig"] = "Wilbur"

puts arr[-1].join(': ')
#=> pig: Wilbur

arr.assoc('cat')[1]

hsh['cat']

arr.each{|a| puts a.join(': ')}

hsh.each_pair{ |k,v| puts "#{k}: #{v}"}

Hash chaos

You already know that you use push or << to add an element to the end of on an existing Array. But these methods do not work for a Hash.

So how do you add a new element (also referred to as a key-value pair for hashes) to the end of a Hash?

You don't. Actually, you just can't add something to the end of a Hash.

The key word is "end". Hash elements (before Ruby 1.9x) do not maintain the order in which they were added.

So, in the table of comparisons in the previous section, even though "pig"=>"Wilbur" was the last key-value pair to be added to hsh, it will not necessarily appear last when iterating through that Hash with each.

As I noted in the aside above, Ruby 1.9 hashes do keep their order. This is a nice optional cherry-on-the-top. Since they've been unordered in Ruby 1.8 and below, I've generally used hashes when the order of the elements is not important.

arr_pets = [["dog", "Fido"], ["cat", "Whiskers"], ["pig", "Wilbur"]]               

hsh_pets = {}
arr_pets.each do |x|
   key = x[0]
   val = x[1]
   hsh_pets[key] = val
end 

#=> hsh_pets = {"cat"=>"Whiskers", "pig"=>"Wilbur", "dog"=>"Fido"}            
   

hsh_pets = {}
arr_pets.each{|x| hsh_pets[x[0]] = x[1]}

   

Why choose a Hash over an Array?

Anything you use a Hash for, you can generally do through an equivalent Array. But a Hash can be easier to maintain and manipulate. Because when it comes to addresses – and indices – humans remember words better than they do numbers.

Let's use as an example a dataset of campaign contributors:

This can be represented as an array nested in an array. Each row is represented as an array, with each field appearing in the array in the same order it does in the table. And all these arrays are themselves stored in an array, in the same order they are listed in original table:

rows = [["Name", "State", "Candidate", "Amount"],
["John Doe", "IA", "Rep. Smithers", "$300"],
["Mary Smith", "CA", "Sen. Nando", "$1,000"],
["Sue Johnson", "TX", "Rep. Nguyen", "$200"]]         
      

To iterate through all the states, for example, you just have to remember that the State column is in the 1-index spot of each sub-array. For the Amount values, their position is in the last index of each sub-array.

puts "Candidate #{rows[2][2]} received #{rows[2][-1]} from a donor named #{rows[2][0]} from the state of #{rows[2][1]}"   

#=> Candidate Sen. Nando received $1,000 from a donor named Mary Smith from the state of CA

Here's the table as an array of hashes:

rows = [
{"Name"=>"John Doe", "State"=>"IA", "Candidate"=>"Rep. Smithers", "Amount"=>"$300"},
{"Name"=>"Mary Smith", "State"=>"CA", "Candidate"=>"Sen. Nando", "Amount"=>"$1,000"},
{"Name"=>"Sue Johnson", "State"=>"TX", "Candidate"=>"Rep. Nguyen", "Amount"=>"$200"}]

Here's the output of a row (note that there is no headers row):

puts "Candidate #{rows[0]['Candidate']} received #{rows[0]['Amount']} from a donor named #{rows[0]['Name']} from the state of #{rows[0]['State']}"   

Candidate Rep. Smithers received $300 from a donor named John Doe from the state of IA

Here's the loop for the array-of-arrays:

rows.each do |row|
   puts "#{row[0]} paid #{row[3]} to #{row[2]}" 
end

# Output:
#=> John Doe paid $300 to Rep. Smithers
#=> Mary Smith paid $1,000 to Sen. Nando
#=> Sue Johnson paid $200 to Rep. Nguyen         
   

This is the loop for an array-of-hashes – which is more readable to you?

rows.each do |row|
   puts "#{row["Name"]} paid #{row["Amount"]} to #{row["Candidate"]}" 
end

This example may seem simple enough. But what if the data format contained many more columns? Keeping track of how the numerical indices map to the data fields positions can be maddening.

To add to the confusion, consider what happens if you want to split the Name field into First name and Last name fields?

In the array-of-arrays version, if you replace the Name column with a LastName and FirstName columns, there needs to be an extra column in the table. If you insert that extra column in place, then every column after that is moved over. For example, the State column would now be in the 2-index position of each subarray.

Which means that everywhere in the code that you used row[1] to refer to the State column has to be changed to row[2]

data_arr = [
   ["Name", "State", "Candidate", "Amount"],
   ["John Doe", "IA", "Rep. Smithers", "$300"],
   ["Mary Smith", "CA", "Sen. Nando", "$1,000"],
   ["Sue Johnson", "TX", "Rep. Nguyen", "$200"]
]         

# first row contains column headers
headers_row = data_arr[0]   

new_data_arr = []
data_arr[1..-1].each do |row|   # [1..-1] skips the first row
   hsh = {}   
   current_column_index = 0
   headers_row.each do |header|   
      hsh[header] = row[current_column_index]
      current_column_index += 1
   end   
   new_data_arr << hsh
end

new_data_arr
#=> [{"Name"=>"John Doe", "Amount"=>"$300", "Candidate"=>"Rep. Smithers", "State"=>"IA"}, {"Name"=>"Mary Smith", "Amount"=>"$1,000", "Candidate"=>"Sen. Nando", "State"=>"CA"}, {"Name"=>"Sue Johnson", "Amount"=>"$200", "Candidate"=>"Rep. Nguyen", "State"=>"TX"}] 
                     

headers_row = data_arr[0]   
new_data_arr = []
data_arr[1..-1].each do |row|   # [1..-1] skips the first row
   hsh = {}   
   headers_row.each_with_index{ |header, idx|   hsh[header] = row[idx] }      
   new_data_arr << hsh
end
                        

Using each and each_pair for hash iteration

The each method works for a Hash. However, it converts each key-value pair into an array like so: [key, value]

{"CA"=>"California"}.each do |pair|
   puts pair[0]
   puts pair[1]
end      

#=> CA
#=> California      
   

To more conveniently access keys and values of a Hash, use the each_pair method:

{'New York'=>'Knicks', 'Miami'=>'Heat', 'Boston'=>'Celtics', 
 'Dallas'=>'Mavericks'}.each_pair |key, val| do
   puts "#{key} has the #{val}"
end
#=> New York has the Knicks
#=> Miami has the Heat
#=> Boston has the Celtics
#=> Dallas has the Mavericks

Hashes also have the each_key and each_value, which each return their respective part of key-value pair.

def count_freq(str)
   hsh = {}
   lth = str.length
   str.split('').each do |letter|
      hsh[letter] = hsh.fetch(letter,0) + 1
   end

   # The each_pair method, when given a block, returns the Hash that invoked it
   # i.e. this will be count_freq's return value

   hsh.each_pair{ |key,val|
      hsh[key] = (val/lth.to_f) 
   }

end


count_freq("abcd")
#=> {"a"=>0.25, "b"=>0.25, "c"=>0.25, "d"=>0.25}

count_freq("eeeieeeoueeeiaaaieeeuauaieeieaau")
#=> {"e"=>0.46875, "i"=>0.15625, "o"=>0.03125, "u"=>0.125, "a"=>0.21875}