Ruby Examples > Nil 

#---Nil---

nil in Ruby represents “nothing” or “no value”.
It’s Ruby’s way of saying “this thing is empty” or “this thing doesn’t exist”.
It’s similar to null in other programming languages.

 
x = nil
p x # => nil

Things you should know about nil

nil is an object. It’s the only object of the class NilClass.

 
p x.class # => NilClass

It’s falsey in conditional statements (along with false).

 
if x
  p "x is not nil"
else
  p "x is nil"
end
## => "x is nil"

You can check for nil using either .nil? or comparing with nil.

 
p "x is NOT nil" if x
p "x IS nil" if x.nil?    # => "x IS nil"
p "x is still nil" if x == nil  # => "x is still nil"

nil is not the same as any of these:
an empty string (""), zero (0), an empty array, ([]) an empty hash ([]), or an empty object.
(So be careful when you compare any object with nil.)

 
p nil == '' # => false
p nil == 0 # => false
p nil == [] # => false
p nil == {} # => false
p nil == Object.new # => false

But nil is nil. So you can compare 2 variables that are nil.

 
y = nil
p x == y # => true

When you try to access a hash key that doesn’t exist, you get nil.

 
h = {a: 'aa', b: 'bb'}
p h[:a] # => "aa"
p h[:c] # => nil

(If you want it to blow up with an exception saying there’s no such key, you must use fetch)

 
p h.fetch(:c)
## => 💥 blows up with:
## key not found: :c (KeyError)

When you access an array index that’s out of bounds, you get nil:

 
arr = [11, 22, 33]
p arr[2] # => 33
p arr[3] # => nil
p arr.fetch(3)
## => 💥 blows up with:
## index 3 outside of array bounds: -3...3 (IndexError)

Zero-value of things

In Go, there’s a concept called “zero-value”.
If you declare a variable and give it no initial value, then a default value based on its type is assumed.
  • For an int variable, it’ll be 0
  • For a string, it is "" (an empty string)
  • For a bool, it is false. And so on.

In Ruby, we can get something like that with the nil.to_* helper methods.

 
p nil.to_s # => ""
p nil.to_i # => 0
p nil.to_f # => 0.0
p nil.to_a # => []
p nil.to_h # => {}
p nil.to_json # => "null"
p nil.to_yaml # => "---\n"

Filtering out the nil items

Sometimes, nil seeps into an array or a hash. But you might not want it. You most likely only want the non-nil items in the array/hash.

 
arr = [11, 22, nil, 33, 44, nil]
h = { a: 'aa', b: nil, c: 'cc' }

You can get them with compact.

 
p arr.compact # => [11, 22, 33, 44]
p h.compact # => {a: "aa", c: "cc"}

Note that the original array and hash are unchanged. .compact only returns a new array/hash with nils removed.

Use .compact! to remove nils even from the original variables.

 
arr.compact!
p arr # => [11, 22, 33, 44]

Safe-navigating the “undefined method for nil” error

For an object to successfully respond to a method, it should first know about it.

 
name = 'john wick'
p name.upcase # => "JOHN WICK"

If you call a method that the object does not know about it, Ruby will scold you.

 
name = nil
p name.upcase
## => 💥 blows up with:
## undefined method 'upcase' for nil (NoMethodError)

And if that object is nil, you can avoid the exception by using the safe navigation operator &. It will return nil instead.

 
p name&.upcase # => nil

Use this functionality with care. In the example above, it is okay to use &. only if it’s okay for name to be nil.

Official doc

NilClass

Useful links

Go’s zero-values

Next topic: Boolean .

Say hi to author pras | Thanks Go By Example