Ruby Examples: Boolean

#---Boolean---

true and false are the two boolean objects that Ruby gives us to make decisions.

true is the only object of the class TrueClass, and false is the only object of the class FalseClass.

              p true.class # => TrueClass
p false.class # => FalseClass
            

true, false vs Truthy, Falsy (Caveat)

The conditions you give in the conditionals must evaluate to true or false. But they can also evaluate to a truthy or falsy value as well.

What?

Yes. Truthy things are things that are considered true in the Eye Of The God. Falsy things… are not.

There are only two falsy things in Ruby:
false itself. And the ever absent nil.

Everything else is truthy. Everything else.

This means things like an empty string, empty array, empty hash, the integer zero 0, float zero 0.0 are all considered truthy in Ruby.
So when you use these in conditionals, know that these will be evaluated as true (unlike in some other languages).

So be careful.

              str = ''
if str
  p "There's something"
else
  p "There's nothing"
end
## => "There's something"
            

Here, you probably expected the else part to run. But you got tripped.

The right way to check for empty string is:

              if str.empty? # or str.size == 0
  p "There's nothing"
else
  p "There's something"
end
## => "There's nothing"
            

Convert an Object to Boolean

You can get the boolean context of any ruby object with the “bang” boolean negation operator !:

prefix an object with a single bang (!) to get its opposite boolean value. (Also called the not operator.)

              p !'some string' # => false
p !"" # => false
p ![] # => false
p ![11, 22, 33] # => false
p !nil # => true
            

prefix an object with a double bang (!!) to get its actual boolean value. (Also called the not not operator.)

              p !!'some string' # => true
p !!"" # => true
p !![] # => true
p !![11, 22, 33] # => true
p !!nil # => false
            

These are useful when you define interrogative methods:

              def no_posts?
  !has_posts?
end
            

Note that you don’t have to use the not not operator in the conditionals every time to check the object’s truthiness. You can use the object as-is. Ruby will still infer it correctly. (But be careful of the caveat above.)

h = {a: 'aa', b: 'bb'}
p 'h is truthy' if h
## => "h is truthy"
## (What happens if h is an empty hash?)