Digging Deeper

There is more to Ruby comparison operators than meets the eye. Here you will learn about their effects and side effects and discover how to break out of blocks when a condition is met.

Boolean Operators

The following operators are available in Ruby for testing expressions that may yield true or false values.

Be careful when using the alternative Boolean operators. Because of the difference in precedence, conditions will be evaluated in different orders and may yield different results.

Consider the following:

boolean_ops.rb

# Example 1
if ( 1==3 ) and (2==1) || (3==3) then
   puts('true')
else
   puts('false')
end

# Example 2
if ( 1==3 ) and (2==1) or (3==3) then
   puts('true')
else
   puts('false')
end

These may look the same at first sight. In fact, Example 1 prints “false,” while Example 2 prints “true.” This is entirely because or has lower precedence than ||. As a consequence, Example 1 tests “if 1 equals 3 [false] and (either 2 equals 1 or 3 equals 3) [true].” Because one of these two necessary conditions is false, the entire test returns false.

Now look at Example 2. This tests “(if 1 equals 3 and 2 equals 1) [false] or 3 equals 3 [true].” This time, you need only one of the two tests to succeed; the second test evaluates to true so the entire tests returns true.

The side effects of operator precedence in this kind of test can lead to very obscure bugs. You can avoid these by clarifying the meaning of the test using parentheses. Here, I have rewritten Examples 1 and 2; in each case, the addition of one pair of parentheses has inverted the initial Boolean value returned by the test:

# Example 1 (b) - now returns true
if (( 1==3 ) and (2==1)) || (3==3) then
   puts('true')
else
   puts('false')
end

# Example 2 (b) - now returns false
if ( 1==3 ) and ((2==1) or (3==3)) then
   puts('true')
else
   puts('false')
end

Eccentricities of Boolean Operators

Be warned that Ruby’s Boolean operators can sometimes behave in a curious and unpredictable manner. For example:

eccentricities.rb

puts( (not( 1==1 )) )                # This is okay
puts( not( 1==1 ) )                  # Syntax error in Ruby 1.8
                                     # but okay in Ruby 1.9

puts( true && true && !(true) )      # This is okay
puts( true && true and !(true) )     # This is a syntax error

puts( ((true) and (true)) )          # This is okay
puts( true && true )                 # This is okay
puts( true and true )                # This is a syntax error

In many cases, you can avoid problems by sticking to one style of operator (either and, or, and not or &&, ||, and !) rather than mixing the two. In addition, the generous use of parentheses is recommended!

catch and throw

Ruby provides a pair of methods, catch and throw, which can be used to break out of a block of code when some condition is met. This is Ruby’s nearest equivalent to a goto in some other programming languages. The block must begin with catch followed by a symbol (that is, a unique identifier preceded by a colon), such as :done or :finished. The block itself may be delimited either by curly brackets or by the keywords do and end, like this:

# think of this as a block called :done
catch( :done ){
   # some code here
}

# and this is a block called :finished
catch( :finished ) do
   # some code here
end

Inside the block, you can call throw with a symbol as an argument. Normally you would call throw when some specific condition is met that makes it desirable to skip all the remaining code in the block. For instance, let’s assume the block contains some code that prompts the user to enter a number, divides some value by that number, and then goes on to do a multitude of other complex calculations with the result. Obviously, if the user enters 0, then none of the calculations that follow can be completed, so you would want to skip them all by jumping right out of the block and continuing with any code that follows it. This is one way of doing that:

catch_throw.rb

catch( :finished) do
   print( 'Enter a number: ' )
   num = gets().chomp.to_i
   if num == 0 then
      throw :finished # if num is 0, jump out of the block
   end
      # Here there may be hundreds of lines of
      # calculations based on the value of num
      # if num is 0 this code will be skipped
end
      # the throw method causes execution to
      # jump to here - outside of the block
puts( "Finished" )

You can, in fact, have a call to throw outside the block, like this:

def dothings( aNum )
   i = 0
   while true
      puts( "I'm doing things..." )
      i += 1
      throw( :go_for_tea ) if (i == aNum )
                        # throws to end of go_to_tea block
   end
end

catch( :go_for_tea ){   # this is the :go_to_tea block
      dothings(5)
}

And you can have catch blocks nested inside other catch blocks, like this:

catch( :finished) do
   print( 'Enter a number: ' )
   num = gets().chomp.to_i
   if num == 0 then throw :finished end
      puts( 100 / num )


   catch( :go_for_tea ){
      dothings(5)
   }

   puts( "Things have all been done. Time for tea!" )
end

As with gotos and jumps in other programming languages, catch and throw in Ruby should be used with great care because they break the logic of your code and can, potentially, introduce hard-to-find bugs.