Nothingness & Truth in Ruby Explained
Tags: beginners, firstblog, flatironschool, truthiness
Published: 2020-12-01 07:12:59

As a coding newbie, I still question and sometimes overthink concepts that might seem pretty basic to most programmers. During my pre-bootcamp preparation journey, one of the topics I had to focus on was Ruby Truthiness and Falseness. It triggered my curiosity.

After doing some research, asking questions to my Flatiron School instructors, and discussing with my boyfriend, I discovered the contrast between Ruby's truthiness versus other languages. 

Let's go over some questions and present examples to help explain how it works.


__Why should booleans never confuse you in Ruby?__
If you look at the cover image of this article, you should be able to identify how many objects there were on the different walls. There was nothing or in Ruby terms, **nil**. `nil` represents nothingness. It is also considered "falsy". Yuuup! It's because it is empty. So, is there any other natively falsy object? NO, except for `false` itself, everything else in Ruby is "truthy". In contrast to other languages like JavaScript, where empty strings `""` and `0` are falsy. Ruby considers them truthy because they still represent something and not nothing.

Truthiness and Falseness are language dependent based on what the implementers chose.

```ruby
def check_truthy(var_name, var)
    is_truthy = var ? "truthy" : "falsy"
    puts "#{var_name} is #{is_truthy}"
end

  check_truthy("false", false)
  check_truthy("nil", nil)
  check_truthy("0", 0)
  check_truthy("empty string", "")
  check_truthy("\\n", "\n")
  check_truthy("empty array", [])
  check_truthy("empty hash", {})
```

=> `false is falsy
nil is falsy
0 is truthy
empty string is truthy
\n is truthy
empty array is truthy
empty hash is truthy`

__When do we receive nil?__
`nil` is a special object in Ruby. When we call a method, we know we are going to get something in return. right? Sometimes, when there is nothing to return, it will return `nil`, which represents nothing.
Just like our instructor "Kim" would say: "If it sounds like I am repeating my self. It is because I am".

We could go on and on the philosophical implications of nil, but instead, we’ll just look at how it is used in practice:

Let's say we have this magazines hash;

```ruby
magazines = { :fashion => "style", :sport => "gogo", :travel => "vacation" }
p magazines[:sport]
```

This will print out `"gogo"`. However, what happens if we try to receive the value for a key that has not been defined on the hash?

```ruby
p magazines[:health]
```

This will return;

'nil'

__What kind of methods return a boolean?__
You might have seen some methods that ends with a question mark.

Example: .even?

```ruby
2.even?
```

=> `true`

```ruby
3.even?
```

=> `false`


We call these "Boolean Methods" or "Predicate Methods", because, they return a boolean value. Conventionally, the methods that end with a question mark are reserved for boolean methods.

Apart from the Ruby built-in boolean methods, we can also create our own.
Watch: 

```ruby
def multiples_of_7?(x)
 (x % 7) == 0
end
```

```ruby
multiples_of_7?(21)
```

=> `true`

If we try the same method, passing 5 as an argument, it would then output `false`. Why? Simply because 5 isn't a multiple of 7.


Overall, booleans are simple. Although, it could get tricky in some occasions. Make sure you are able to differentiate between TrueClass class (class that groups true boolean objects) and a FalseClass class (class that groups false boolean objects). Be aware of emptiness and ruby specifics.
 
Happy coding beginnings!