Ruby's Nil vs PHP's Null
It may seem like a boring topic, because in this section we’re literally talking about the concept of nothing. PHP’s
null and Ruby’s
nil may seem similar at surface level because they both represent the idea of an empty variable.
nil is not just a placeholder for empty variables - often it is used as a way to signal application controls. More on that in a bit. First, we need to cover the basics of PHP’s
null in PHP
null is a scalar datatype, meaning that it’s a simple data structure and not an object. This is just common sense.
You can test for
null in a couple of ways. The easiest to understand is the function
isnull($thing). This function will just return a Boolean that represents if the
null or not:
Nil in Ruby
That wasn’t a typo, I’ve capatilized
Nil in the title of this section. That’s because like everything else in Ruby - the concept of nothing is an object. That’s right -
Nil with a capital N is an object in Ruby.
In fact there’s an entire page of documentation on the
NilClass on the Ruby website.
But unlike in PHP where you have global functions lying about at your disposal whenever you need to do a common operation like checking if a variable is nil; instead you’re given methods on the object itself.
To check to see if an object is
Nil in Ruby, we have a method on
Nil itself for that:
thing = nil if thing.nil? puts 'yup thing is definitely not a thing' end => 'yup thing is definitely not a thing'
Coming from a PHP background, this may seem bonkers. How could every object in a lanuage possibly implement the
.nil? method? The answer is that every class in Ruby inherits from a Class called
If you look at the Object Class’s Documentation on the ruby-doc website you’ll see that it implements a variety of methods, one such key method is
Since everything inherits from
Object, therefore everything implements
.nil?. In an way it’s the equivalent of a global function.
Truthy or Falsey
In the beginning I hinted that Ruby’s
nil was a little more than just a signal that a particular variable was empty. It’s also a way of signifing that a variable is falsey.
Falsey means that a value is not truely
false , but if passed to a conditional then it’s treated as if it was one.
nil is not actually
false. They’re 2 different concepts. However, to a conditional, they both mean the same thing.
Sometimes examples speak louder than descriptions. Check these out:
thing = false if !thing puts 'thing is Falsey' end => 'thing is Falsey'
That’s expected right? Let’s try it with
thing = nil if !thing puts 'thing is Falsey' end => 'thing is Falsey'
Same behavior! Ruby is somewhat different in that almost everything is truthy:
'any string'is truthy
However there are only 2 structures in Ruby that are falsey:
Compared to PHP this is a simple concept. In order to know if a particular data structure is truthy or falsey in PHP you can to consort a data type that defines under what conditions a variable is truthy vs falsey.
Here’s the official PHP data type comparisons table
So, long story short. Ruby’s
nil sounds complicated because it’s in fact an object. However, it plays into Ruby’s OOP nature and it provides a guessable path to understanding. The principle of least surprise holds up well here.