Understand What Ruby considers to be True


memo

>
- Every value is true except false and nil
- Unlike in a lot of languages, the number zero is true in Ruby
- If you need to differentite between false and nil, either use the nil? method or == operator with false as the left operand.

> Effective Ruby

true and flase act like global objects, and like any object.

```ruby
[3] pry(main)> true.class
=> TrueClass
[4] pry(main)> false.class
=> FalseClass
```

Detect false

false as the left operand

```
if false == x
 ...
end
```

`==` operator of false is used and `FalseClass#==` is called. If the right operaend is also false object. It returns true.


Bad practice: put false as right operand.

```ruby
[5] pry(main)> class Bad
[5] pry(main)*   def == (other)
[5] pry(main)*     true
[5] pry(main)*   end
[5] pry(main)* end
=> :==
[6] pry(main)> false == Bad.new
=> false
[7] pry(main)> Bad.new == false
=> true
```

## 0 is not false!

```
[14] pry(main)> if 0
[14] pry(main)*   p 'I am TRUE'
[14] pry(main)* end
"I am TRUE"
=> "I am TRUE"
```


## Even nil responseds "Hi, I am nil"

nil.nil?

```
[13] pry(main)> nil.nil?
=> true
```

## Why 0 is not false?
This could be worth to read.
https://gist.github.com/jfarmer/2647362

> Many programming languages, including Ruby, have native boolean (true and false) data types. In Ruby they're called true and false. In Python, for example, they're written as True and False.

http://en.wikipedia.org/wiki/Boolean_data_type
>But oftentimes we want to use a non-boolean value (integers, strings, arrays, etc.) in a boolean context (if statement, &&, ||, etc.). So someone designing a language has to decide what values count as "true" and what count as "false." A non-boolean value that counts as true is called "truthy," and a non-boolean value that counts as false is called "falsey."

http://en.wikipedia.org/wiki/Logical_connective
http://en.wikipedia.org/wiki/Logical_conjunction
> Remember: only true and false are booleans. nil is not a boolean. 0 is not a boolean. [1,2,3] is not a boolean. The string "apple" is not a boolean. When used in a context where a boolean is expected, Ruby evaluates them as boolean.


> Programming languages are software, too! That means the people who built Ruby had to decide what is truthy and what is falsey. Different languages make different decisions.

http://raflabs.com/blogs/silence-is-foo/2010/08/12/nil-true-false-ruby/

> In Ruby only false and nil are falsey. Everything else is truthy (yes, even 0 is truthy).

> In some languages, like C and Python, 0 counts as false. In fact, in Python, empty arrays, strings, and hashes all count as false. In JavaScript, empty strings count as false, but empty arrays count as true.

> Some languages (so-called "strictly typed" languages) go to the other extreme. true evaluates to true, false evaluates to false, and anything else will cause the compiler or interpreter to yell at you: "You can't evaluate a non-boolean value as a boolean!"

> The point is only that different languages can decide what counts as true and what counts as false. There's nothing inherent in an empty string, for example, that make false. The various choices could be reasonable or unreasonable to varying degrees — it'd be strange to ever see the integer 1 or the string "apples" acting as false, for example — but ultimately it's a convention of the programming language.



ref: 
Effective Ruby