View source for Ruby Flow Control

One of the most powerful features of Ruby (and every other programming or scripting language for that matter) is the ability to build intelligence and logic into code. This is achieved through the use of ''control structures'' which decide what code is executed based on logical expressions.

In this chapter of [[Ruby Essentials]] we will look at how such control structures are built.

== The Ruby if Statement ==

The ''if'' statement is the most basic of the Ruby control structures. ''if'' statements simply specify a section of Ruby script to be executed when a specified criteria is met. The syntax for an ''if'' statement is as follows:

if ''expression'' then<br>
&nbsp;&nbsp;''ruby code''<br>
end

In the above outline, the ''expression'' is a logical expression that will evaluate to either true or false. if the expression is true, then the code represented by ''ruby code'' will execute. Otherwise the code is skipped. ''end'' marks the end of the ''if'' statement.

Let's look at an example:

<pre>
if 10 < 20 then
    print "10 is less than 20"
end
</pre>

When executed, the script will display the string "10 is less than 20", because the 10 < 20 expression evaluated to true.

If this was any language other than Ruby we would now move on to the next section. Except that this is Ruby we are talking about, so we have more flexibility. Firstly, we can drop the ''then'' keyword and get the same result:

<pre>
if 10 < 20
    print "10 is less than 20"
end
</pre>

We can also place the ''if'' after the ''print'' statement, and in doing so, drop the ''end'' statement:

<pre>
print "10 is less than 20" if 10 < 20
</pre>

Similarly, we can place a colon (:) between the ''if'' expression and the statement to be executed:

<pre>
if 10 < 20: print "10 is less than 20" end
</pre>

The expression to be evaluated can also include logical operators. For example:

<pre>
if firstname == "john" && lastname == "smith" then
print "Hello John!"
end
</pre>

== Using else and elsif Constructs ==

The ''if'' control structure outlined above allows you to specify what should happen if a particular expression evaluates to ''true''. It does not, however, provide the option to specify something else that should happen in the event that the expression evaluates to ''false''. This is where the ''if ... else'' construct comes into play.

The syntax for ''if ... else'' is similar to the simple ''if'' statement with the exception that the ''else'' statement can be used to specify alternate action:

<pre>
if customerName == "Fred"
      print "Hello Fred!"
else 
      print "You're not Fred! Where's Fred?"
end
</pre>

As shown in the above example the code block following the ''if'' statement is executed when the expression is evaluated to be true (i.e the customerName variable contains the string "Fred") and the script after the ''else'' statement is executed when the customerName does not match the string "Fred".

''elsif'' structures take the ''if ... else ...'' concept a step taken a step further to implement ''if ... else ... if ... else ...'' structures. For example:

<pre>
if customerName == "Fred"
      print "Hello Fred!"
elsif customerName == "John"
      print "Hello John!" 
elsif customername == "Robert"
      print "Hello Bob!"
end
</pre>

This construct may also be expressed a little more economically using a colon (:) to separate the ''elsif'' from the ''print'' statement:

<pre>
if customerName == "Fred" : print "Hello Fred!"
elsif customerName == "John" : print "Hello John!" 
elsif customername == "Robert" : print "Hello Bob!"
end
</pre>

== The Ruby Ternary Operator ==

Ruby uses something called a ''ternary operator'' to provide a shortcut way of making decisions. The syntax of the ternary operator is as follows:

[condition] ? [true expression]:[false expression]

The way this works is that [condition] is replaced with an expression that will return either true or false. If the result is true then the expression that replaces the [true expression] is evaluated. Conversely, if the result was false then the [false expression] is evaluated. Let's see this in action:

<pre>
irb(main):182:0> customerName = "Fred"
=> "Fred"
irb(main):183:0> customerName == "Fred" ? "Hello Fred" : "Who are you?"
=> "Hello Fred"
</pre>