If and Else

We saw how variables let us refer to data not yet known to us when we're writing a program.

Similarly, if/else statements allow us to create different paths for our program to take depending on what happens during the program's execution.

if my_bank_account_balance > 50.00
   puts "I'm eating steak!"
else
   puts "I'm eating ramen :("
end   

Tomorrow, you might plan to go out for steak dinner if your tax refund arrives in the mail. If it doesn't, then you'll plan on eating ramen. Likewise, in your programs, you plan for hypothetical situations. Such as: what happens if the website you want to scrape is down?

This chapter looks at how to put some branches in our program so it no longer flows in a single, narrow path.

The if

The if statement is how we create a branch in our program flow. The if statement includes a true-or-false expression:

if 4 == 2 + 2
   puts "The laws of arithmetic work today"
end   

If that expression evaluates to true, then the Ruby interpreter will execute the puts statement that follows the if statement. However, if the expression's result is false, then the Ruby interpreter skips the puts.

def even_or_odd(val)
   if val % 2 == 0
      return "#{val} is even"
   end
   
   if val % 2 == 1
      return "#{val} is odd"
   end
end
   

Try out that code. Pass in a number to the even_or_odd method that has a remainder of 1 when divided by 2 – i.e. an odd number. The code inside the first if statement won't execute. Here's a breakdown of the new terms:

if

This keyword indicates that the branch of code following it will execute if the if condition is true

==

Two consecutive equals signs is the operator for an equality test. When the value on the left of == is equal to the right-side value, then the result is true.

end

This keyword in this context indicates the end of the branch. If the if statement was false, this is where the program resumes, as it skips the branch of code following the if.

In the code example above, the method first tests to see if the remainder of val – when divided by 2 – is equal to 0. So, if val % 2 is 0, then the method returns "#{val} is even".

However, if val is odd, then the first if test fails because the remainder is non-zero. The program moves on to the next if statement: val is tested to see if its remainder is 1 when divided by 2. So, if val % 2 is equal to 1, then the method returns "#{val} is odd".

When you write the even_or_odd method, you can't know what number the user will pass in for the argument. The if statement gives your program the ability to respond with the appropriate answer.

Booleans: the truth about true and false

The words true and false have special meaning in programming languages. In Ruby, they have the datatypes of TrueClass and FalseClass, respectively.

The specific class names aren't important to remember. The main point is that true and false – note the lack of String-denoting quotes – are the answers to comparison tests.

Such as: is 10 times 2 greater than 0?.

10 * 2 > 0

Or: is -1 equal to 1?

-1 == 1

The results, respectively, are the values true and false.

These two values – true and false – are not Strings. Test this out for yourself:

true == "true"   #   false
false == false   #   true      
   

A common mistake is to use a single equals sign = when a double equals sign == is called for. Remember that the single = assigns a value to a variable. The double == is used to test for equality.

In other words:

=

set equal to

==

is equal to?

Virtually every value – besides false and nil – evaluates as true by an if statement. Ergo:

x = "To be or not to be"
if x
   puts "x exists!"
end
#=> x exists!

if x == 1
   puts "x is equal to 1"
end
#=> [branch does not execute]   

if x = 1
   puts "The variable x is now number 1!"
end
#=> The variable x is now number 1!   

puts x   #=>   1
      

In the first if statement, we are saying: if there is something in the variable x... Since we assigned "To be or not to be" to x, the answer is always true.

In the second if statement, because we used a single equals sign, the if statement actually uses the assignment operator. So the expression first assigns the value of 1 to x. The if statement then evaluates whether anything is in x.

The answer to if 1 is always true, so we get the unexpected output as above.

num = 100
if num <= 100 || num % 2 == 1
    puts "Less or equal to 100 or odd"
end   
 
#=> Less or equal to 100 or odd
    

num = 12
if num != "Twelve"
    puts "Not twelve"
end        
#=> Not twelve

puts !(6 == 7)  #=> true
        

puts 6 != 7 #=> true
            

puts !6 == 7    #=> false      
    

puts false == 7    #=> false      
    

if puts("puts is a method returning nil")
   # program will never go here
end

nil == false   #   false; nil is not technically the same as false
   

puts("hello world").nil?   #   true
42.nil?   #   false
0.nil?   #   false
"".nil?   #   false
nil.nil?   #   true      
   

Going elsewhere

Let's tighten up the even_or_odd method from the previous section:

def even_or_odd(val)
   if val % 2 == 0    # any number divided by 2 is even if remainder is 0
      "#{val} is even"
   else    # if not even, then must be odd
      "#{val} is odd"
   end
end

The new keyword is else and leads to a path for a program to resume if the conditions for an if statement weren't met. An else statement must come after an if statement. Or else, what would the else be an alternative to?

Notice how there are no return statements. Remember that a Ruby method by default will return the value in its final line. When the argument val is even, the code including and following the else statement doesn't exist, as far as Ruby is concerned.

So "#{val} is even" will be the return value of even_or_odd, without an explicit return statement in the method's final line.

even_or_odd(4.2)   #=>   "4.2 is odd"

def even_or_odd(val)
   if !(val.is_a? Fixnum)
      "#{val} is not an integer"
   elsif val % 2 == 0    
      "#{val} is even"
   else             
      "#{val} is odd"
   end
end
         

if val > 10
   puts "Big" 
end  

if val > 10 && val <= 0    
   puts "Small" 
end

if val > 14 && val < 100 && val % 2==0 
   puts "Dog"
elsif (val >= 100 && val < 1000) || val % 2==1
   puts "Elephant"
else
   puts "Bananas"
end   

Variations on if

Inline if statements

Ruby provides a neat inline form for if/else statements, when the logic in your script is simple:

num = -10
num += -1 if num < 0
puts num   
#=> -11

As opposed to:

num = -10
if num < 0
   num += -1
end
puts num   
#=> -11

When to use if =

An experienced coder may choose to use a single equals sign – i.e. the assignment operator – in the following situation:

If the value on the right side of = is the return value of a method or expression – and if that method either returns something or nothing at all.

In the latter case, when the return value is nil, the expression is considered to be false:

# remember that puts returns nil
if x = (puts 'hello world') 
   puts "Successful assignment. x is now #{x}"
end
#=> hello world
# the code block does not execute   

# upcase returns a string
if x = ('hello world'.upcase) 
   puts "Successful assignment. x is now: #{x}"
end

#=> Successful assignment. x is now: HELLO WORLD

In both cases, the value is conveniently assigned to the variable on the left.

require 'open-uri'
if page = open("http://google.com")         
   puts "Google's homepage currently contains the following text: #{page.read}"
end

This is more concise than:

require 'open-uri'
page = open("http://google.com")            
if page
   puts "Google's homepage currently contains the following text: #{page.read}"
end

This use of if x = is handy. But it can be easily misunderstood when you review your code. Stick with the verbose version for now.

Logic and flow

One of the most common novice mistakes with if/else is thinking that multiple if statements are equivalent to using elsif and else.

Think of if as creating a two-pronged fork in the road. The script has the option of taking or avoiding that side-path created by the if. If it does go the if, when the script reaches the end, it continues on linearly until the next fork.

When an elsif or else follows an if statement, it creates a three-prong-or-more fork in the road. The script has more choices but can only go down one of these routes.

Here's a food metaphor:

• Restaurant A offers you the choice of roast chicken, or ribeye, or salad, or soup.
• Restaurant B offers you a multi-course meal: soup, and/or salad, and/or chicken and/or ribeye.

What each restaurant serves you is dependent on how hungry you feel represented by a number from 1 to 10.

Here's how Restaurant A's service would be implemented in code:

def restaurant_a(how_hungry_are_you)
   meal = ""
   if how_hungry_are_you >= 9
      meal = "Ribeye" 
   elsif how_hungry_are_you >= 7
      meal = "Chicken"
   elsif how_hungry_are_you >= 4
      meal = "Soup"
   else
      meal = "Salad"
   end   
end

puts restaurant_a(10)   #=>   "Ribeye"
puts restaurant_a(4)   #=>   "Soup"
            
      

Here is the code for Restaurant B:

def restaurant_b(how_hungry_are_you)
   meal = ""
   meal += "Ribeye " if how_hungry_are_you >= 9
   meal += "Chicken " if how_hungry_are_you >= 7
   meal += "Soup " if how_hungry_are_you >= 4
   meal += "Salad " if how_hungry_are_you >= 1               
end

puts restaurant_b(3)   #=>   "Salad "
puts restaurant_b(4)   #=>   "Soup Salad "
puts restaurant_b(10)   #=>   "Ribeye Chicken Soup Salad "
   

The branch logic for Restaurant B is more compact but its service is fundamentally different than Restaurant A's. Restaurant A gives you one meal depending on how hungry you are. A 10 or above will net you a ribeye steak, at most.

At Restaurant B, however, a 10 gets you everything. Because 10 is not only greater than the criteria for B's ribeye (greater or equal to 9), but it satisfies the hunger criteria for all the other meal choices.

def restaurant_a2(how_hungry_are_you)
   meal = "Ribeye" if how_hungry_are_you >= 9 
   meal = "Chicken" if how_hungry_are_you < 9 && how_hungry_are_you >= 7
   meal = "Soup" if how_hungry_are_you < 7 && how_hungry_are_you >= 4
   meal = "Salad" if how_hungry_are_you < 4 && how_hungry_are_you >= 1
   return meal               
end
            

The FizzBuzz Game

Conditional statements allow for both incredibly useful program functionality and crippling bugs. Let's test how well you understand them by tackling a technical programming interview question that, according to developer Imran Ghor, has stumped "the majority of comp sci graduates."

It's called the FizzBuzz game and it is frequently invoked during discussions about the general competency among programmers. There are a variety of ways to solve it and you've learned enough to answer it competently.

for i in 1..100
   if i % 15 == 0
      puts "FizzBuzz"
   elsif i % 3 == 0
      puts "Fizz"
   elsif i % 5 == 0
      puts "Buzz"
   else
      puts i
   end
end

   1
   2
   Fizz
   4
   Buzz
   Fizz
   7
   8
   Fizz
   Buzz
   11
   Fizz
   13
   14
   FizzBuzz
   16
   17
   Fizz
   19
   Buzz
   Fizz
   22
   23
   Fizz
   Buzz
   26
   ... and so forth   

for i in 1..100
   if i % 3==0
      puts "Fizz"
   elsif i % 5 == 0
      puts "Buzz"
   elsif i % 15 == 0
      puts "FizzBuzz"
   else
      puts i
   end
end
                           

1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
Fizz
16
...

for i in 1..100
   puts "FizzBuzz" if i % 15 == 0
   puts "Fizz" if i % 3 == 0
   puts "Buzz" if i % 5 == 0
   puts i
end
            

1
2
Fizz
3
4
Buzz
5
Fizz
6
7
8
Fizz
9
Buzz
10
11
Fizz
12
13
14
FizzBuzz
Fizz
Buzz
15   
   

for i in 1..100
   str = ''
   str += 'Fizz' if i%3==0
   str += 'Buzz' if i%5==0
   puts (str == '' ? i : str)
end
            

# puts (str == '' ? i : str)
# is the same as:
if str == ''
   puts i
else
   puts str
end