- 4.1 Motivation
- 4.2 Strings and Methods
- 4.3 Other Data Structures
- 4.4 Ruby Classes
- 4.5 Exercises
This chapter is from the book
This chapter is from the book
This chapter is from the book
4.3 Other Data Structures
Though web apps are ultimately about strings, actually making those strings requires using other data structures as well. In this section, we'll learn about some Ruby data structures important for writing Rails applications.
4.3.1 Arrays and Ranges
An array is just a list of elements in a particular order. We haven't discussed arrays yet in Rails Tutorial, but understanding them gives a good foundation for understanding hashes (Section 4.3.3) and for aspects of Rails data modeling (such as the has_many association seen in Section 2.3.3 and covered more in Section 11.1.2).
So far we've spent a lot of time understanding strings, and there's a natural way to get from string to arrays using the split method:
>> "foo bar baz".split # Split a string into a three-element array => ["foo", "bar", "baz"] |
The result of this operation is an array of three strings. By default, split divides a string into an array by splitting on whitespace, but you can split on nearly anything else:
>> "fooxbarxbazx".split('x')
=> ["foo", "bar", "baz"]
|
As is conventional in most computer languages, Ruby arrays are zero-offset, which means that the first element in the array has index 0, the second has index 1, and so on:
>> a = [42, 8, 17] => [42, 8, 17] >> a[0] # Ruby uses square brackets for array access. => 42 >> a[1] => 8 >> a[2] => 17 >> a[-1] # Indices can even be negative! => 17 |
We see here that Ruby uses square brackets to access array elements. In addition to this bracket notation, Ruby offers synonyms for some commonly accessed elements:
>> a # Just a reminder of what 'a' is => [42, 8, 17] >> a.first => 42 >> a.second => 8 >> a.last => 17 >> a.last == a[-1] # Comparison using == => true |
This last line introduces the equality comparison operator == , which Ruby shares with many other languages, along with the associated != ("not equal"), etc.:
>> x = a.length # Like strings, arrays respond to the 'length' method. => 3 >> x == 3 => true >> x == 1 => false >> x != 1 => true >> x >= 1 => true >> x < 1 => false |
In addition to length (seen in the first line above), arrays respond to a wealth of other methods:
>> a.sort => [8, 17, 42] >> a.reverse => [17, 8, 42] >> a.shuffle => [17, 42, 8] |
By the way, the shuffle method is available only on Ruby 1.8.7 or later; if you're using 1.8.6, you can use
>> a.sort_by { rand }
|
instead.
You can also add to arrays with the "push" operator, << :
>> a <<7 # Pushing 7 onto an array [42, 8, 17, 7] >> a << "foo" << "bar" # Chaining array pushes [42, 8, 17, 7, "foo", "bar"] |
This last example shows that you can chain pushes together, and also that, unlike arrays in many other languages, Ruby arrays can contain a mixture of different types (in this case, integers and strings).
Before we saw split convert a string to an array. We can also go the other way with the join method:
>> a
[42, 8, 17, 7, "foo", "bar"]
>> a.join # Join on nothing
=> "428177foobar"
>> a.join(', ') # Join on comma-space
=> "42, 8, 17, 7, foo, bar"
|
Closely related to arrays are ranges, which can probably most easily be understood by converting them to arrays using the to_a method:
>> 0..9 => 0..9 >> 0..9.to_a # Oops, call to_a on 9 ArgumentError: bad value for range >> (0..9).to_a # Use parentheses to call to_a on the range => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] |
Though 0..9 is a valid range, the second expression above shows that we need to add parentheses to call a method on it.
Ranges are useful for pulling out array elements:
>> a = %w[foo bar baz quux] # Use %w to make a string array ["foo", "bar", "baz", "quux"] >> a[0..2] => ["foo", "bar", "baz"] |
Ranges also work with characters:
>> ('a'..'e').to_a
=> ["a", "b", "c", "d", "e"]
|
4.3.2 Blocks
Both arrays and ranges respond to a host of methods that accept blocks, which are simultaneously one of Ruby's most powerful and most confusing features:
>> (1..5).each { |i| puts2*i}
2
4
6
8
10
=> 1..5
|
This code calls the each method on the range (1..5) and passes it the block { |i| puts2*i }. The vertical bars around the variable name in |i| are Ruby syntax for a block variable, and it's up to the method to know what to do with the block; in this case, the range's each method can handle a block with a single local variable, which we've called i , and it just executes the block for each value in the range.
Curly braces are one way to indicate a block, but there is a second way as well:
>> (1..5).each do |i| ?> puts2*i >> end 2 4 6 8 10 => 1..5 |
Blocks can be more than one line, and often are. In Rails Tutorial we'll follow the common convention of using curly braces only for short one-line blocks and the do..end syntax for longer one-liners and for multi-line blocks:
>> (1..5).each do |number| ?> puts 2 * number >> puts '--' >> end 2 -- 4 -- 6 -- 8 -- 10 -- => 1..5 |
Here I've used number in place of i just to emphasize that any variable name will do.
Unless you already have a substantial programming background, there is no shortcut to understanding blocks; you just have to see them a lot, and eventually you'll get used to them.9 Luckily, humans are quite good at making generalizations from concrete examples; here are a few more, including a couple using the map method:
>> 3.times { puts "Betelgeuse!" } # 3.times takes a block with no variables.
"Betelgeuse!"
"Betelgeuse!"
"Betelgeuse!"
=> 3
>> (1..5).map { |i| i**2 } # The ** notation is for 'power'.
=> [1, 4, 9, 16, 25]
>> %w[a b c] # Recall that %w makes string arrays.
=> ["a", "b", "c"]
>> %w[a b c].map { |char| char.upcase }
=> ["A", "B", "C"]
|
As you can see, the map method returns the result of applying the given block to each element in the array or range.
By the way, we're now in a position to understand the line of Ruby I threw into Section 1.4.4 to generate random subdomains:10
('a'..'z').to_a.shuffle[0..7].join
|
Let's build it up step by step:
>> ('a'..'z').to_a # An alphabet array
=> ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o",
"p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"]
>> ('a'..'z').to_a.shuffle # Shuffle it!
=> ["c", "g", "l", "k", "h", "z", "s", "i", "n", "d", "y", "u", "t", "j", "q",
"b", "r", "o", "f", "e", "w", "v", "m", "a", "x", "p"]
>> ('a'..'z').to_a.shuffle[0..7] # Pull out the first eight elements.
=> ["f", "w", "i", "a", "h", "p", "c", "x"]
>> ('a'..'z').to_a.shuffle[0..7].join # Join them together to make one string.
=> "mznpybuj"
|
4.3.3 Hashes and Symbols
Hashes are essentially a generalization of arrays: You can think of hashes as basically like arrays, but not limited to integer indices. (In fact, some languages, especially Perl, call hashes associative arrays for this reason.) Instead, hash indices, or keys, can be almost any object. For example, we can use strings as keys:
>> user = {} # {} is an empty hash
=> {}
>> user["first_name"] = "Michael" # Key "first_name", value "Michael"
=> "Michael"
>> user["last_name"] = "Hartl" # Key "last_name", value "Hartl"
=> "Hartl"
>> user["first_name"] # Element access is like arrays
=> "Michael"
>> user # A literal representation of the hash
=> {"last_name"=>"Hartl", "first_name"=>"Michael"}
|
Hashes are indicated with curly braces containing key-value pairs; a pair of braces with no key-value pairs—i.e., {}—is an empty hash. It's important to note that the curly braces for hashes have nothing to do with the curly braces for blocks. (Yes, this can be confusing.) Though hashes resemble arrays, one important difference is that hashes don't generally guarantee keeping their elements in a particular order.11 If order matters, use an array.
Instead of defining hashes one item at a time using square brackets, it's easy to use their literal representation:
>> user = { "first_name" => "Michael", "last_name" => "Hartl" }
=> {"last_name"=>"Hartl", "first_name"=>"Michael"}
|
Here I've used the usual Ruby convention of putting an extra space at the two ends of the hash—a convention ignored by the console output. (Don't ask me why the spaces are conventional; probably some early influential Ruby programmer liked the look of the extra spaces, and the convention stuck.)
So far we've used strings as hash keys, but in Rails it is much more common to use symbols instead. Symbols look kind of like strings, but prefixed with a colon instead of surrounded by quotes. For example, :name is a symbol. You can think of symbols as basically strings without all the extra baggage:12
>> "name".length 4 >> :name.length NoMethodError: undefined method 'length' for :name:Symbol >> "foobar".reverse => "raboof" >> :foobar.reverse NoMethodError: undefined method 'reverse' for :foobar:Symbol |
Symbols are a special Ruby data type shared with very few other languages, so they may seem weird at first, but Rails uses them a lot, so you'll get used to them fast.
In terms of symbols as hash keys, we can define a user hash as follows:
>> user = { :name => "Michael Hartl", :email => "michael@example.com" }
=> {:name=>"Michael Hartl", :email=>"michael@example.com"}
>> user[:name] # Access the value corresponding to :name.
=> "Michael Hartl"
>> user[:password] # Access the value of an undefined key.
=> nil
|
We see here from the last example that the hash value for an undefined key is simply nil .
Hash values can be virtually anything, even other hashes, as seen in Listing 4.5.
Listing 4.5. Nested hashes
>> params = {} # Define a hash called 'params' (short for 'parameters').
=> {}
>> params[:user]={:name => "Michael Hartl", :email => "mhartl@example.com" }
=> {:name=>"Michael Hartl", :email=>"mhartl@example.com"}
>> params
=> {:user=>{:name=>"Michael Hartl", :email=>"mhartl@example.com"}}
>> params[:user][:email]
=> "mhartl@example.com"
These sorts of hashes-of-hashes, or nested hashes, are heavily used by Rails, as we'll see starting in Section 8.2.
As with arrays and ranges, hashes respond to the each method. For example, consider a hash named flash with keys for two conditions, :success and :error :
>> flash={ :success => "It worked!", :error => "It failed. :-(" }
=> {:success=>"It worked!", :error=>"It failed. :-("}
>> flash.each do |key, value|
?> puts "Key #{key.inspect} has value #{value.inspect}"
>> end
Key :success has value "It worked!"
Key :error has value "It failed. :-("
|
Note that, while the each method for arrays takes a block with only one variable, each for hashes takes two, a key and a value. Thus, the each method for a hash iterates through the hash one key-value pair at a time.
The last example uses the useful inspect method, which returns a string with a literal representation of the object it's called on:
>> puts flash # Put the flash hash as a string (with ugly results).
successIt worked!errorIt failed. :-(
>> puts flash.inspect # Put the flash hash as a pretty string
{:success=>"It worked!", :error=>"It failed. :-("}
>> puts :name, :name.inspect
name
:name
>> puts "It worked!", "It worked!".inspect
It worked!
"It worked!"
|
By the way, using inspect to print an object is common enough that there's a shortcut for it, the p function:
>> p flash # Same as 'puts flash.inspect'
{:success=>"It worked!", :error=>"It failed. :-("}
|
4.3.4 CSS Revisited
It's time now to revisit the lines from Listing 4.4 used in the layout to include the cascading style sheets:
<%= stylesheet_link_tag 'blueprint/screen', :media => 'screen' %> <%= stylesheet_link_tag 'blueprint/print', :media => 'print' %> |
We are now nearly in a position to understand this. As mentioned briefly in Section 4.1.2, Rails defines a special function to include stylesheets, and
stylesheet_link_tag 'blueprint/screen', :media => 'screen' |
is a call to this function. But there are two mysteries. First, where are the parentheses? In Ruby, they are optional; these two lines are equivalent:
# Parentheses on function calls are optional.
stylesheet_link_tag('blueprint/screen', :media => 'screen')
stylesheet_link_tag 'blueprint/screen', :media => 'screen'
|
Second, the :media argument sure looks like a hash, but where are the curly braces? When hashes are the last argument in a function call, the curly braces are optional; these two lines are equivalent:
# Curly braces on final hash arguments are optional.
stylesheet_link_tag 'blueprint/screen', { :media => 'screen' }
stylesheet_link_tag 'blueprint/screen', :media => 'screen'
|
So, we see now that each of the lines
<%= stylesheet_link_tag 'blueprint/screen', :media => 'screen' %> <%= stylesheet_link_tag 'blueprint/print', :media => 'print' %> |
calls the stylesheet_link_tag function with two arguments: a string, indicating the path to the stylesheet, and a hash, indicating the media type ( 'screen' for the computer screen and 'print' for a printed version). Because of the <%= %> brackets, the results are inserted into the template by ERb, and if you view the source of the page in your browser you should see the HTML needed to include a stylesheet (Listing 4.6).13
Listing 4.6. The HTML source produced by the CSS includes
<link href="/stylesheets/blueprint/screen.css" media="screen" rel="stylesheet" type="text/css" /> <link href="/stylesheets/blueprint/print.css" media="print" rel="stylesheet" type="text/css" />