# The difference between 0, false and null

Published December 7, 2011

There’s been a few things over the years that I’ve never really understood, and it took me quite a while to “get” them. Obviously I tried, but nobody’s descriptions ever made sense. Hopefully, this brief look at this topic might help at least one other person.

I’m going to write about 0, `false` and `null` – why they’re different, and why that’s important. I’m also going to write about the difference between a string and an integer, and ways of using all this in `if` and `for`.

0 is a number, as I’m sure you know. In binary it takes the part of “off” or “false”, and 1 is “on” or “true”. This is why 0 and false are often mixed.

There’s two types of 0 in PHP. The first is the integer (meaning, a whole number) 0, and the second is a string.

You’d form these in PHP like so

``````\$var1 = 0;
\$var2 = '0';
``````

`\$var1` is an integer, a whole number. You can use it in maths. `\$var2` is a string, a word or sentence. It’s just text as far as PHP is concerned, you might as well write the word “zero”.

If you’ve been using PHP for a while, you’ve probably got away without worrying about this and are probably wondering what I’m going about.

``````if (\$var1 == \$var2)
{
echo 'Oh, it worked!';
}
``````

What’s going on here? It’s because of how the operator works.

• `=` is an ‘assignment operator’. `\$var = 'cheese'` sets `\$var` to be a string of the word ‘cheese’.
• `==` is an ‘equal operator’. It compares the values.
• `===` is an ‘identical operator’. It compares the value and the type.

The key difference is between equal and identical. The `if` statement I wrote above works because I’m comparing the integer 0 with a string 0. Both values are 0, of sorts.

But what happens if I try using three equals signs.

``````if (\$var1 === \$var2)
{
echo 'Ain’t going to happen!';
}
``````

Now I’m comparing types too, and a string isn’t an integer.

In the computer world, 0 is also used as `false`, as I discussed earlier. This works for operators too.

``````\$var1 = 0;
\$var2 = false;

if (\$var1 == \$var2)
{
echo 'Yep, totally worked.';
}
``````

But, again, if I used an identical operator, it would fail.

So why on earth is this important?

Let’s say you’re working with a database. You ask the database to count rows, and then let the user know how many rows there are.

`get_number_of_rows` is a fictional function I made up that returns either an integer of the number of rows, or it returns `false` if the database is broken.

``````\$rows = get_number_of_rows();

if (\$rows == 0)
{
echo 'There’s no rows :(';
}
``````

The problem is here, that if the database failed to load, it would return `false`. Using an equal operator (two equals signs), that matches 0 so the user would see “There’s no rows :(”.

So we use the identical operator to help tell the difference.

``````\$rows = get_number_of_rows();

if (\$rows === false)
{
echo 'Oh dear! Broken!';
}
elseif (\$rows === 0)
{
echo 'No rows :(';
}
else
{
echo 'There are '.\$rows.' rows!';
}
``````

This is still pretty bad though, as just because the row number isn’t `false` or 0, it could still be a string of some sort. So we’d use a greater than operator to help find out what’s really going on.

``````if (\$rows === false)
{
echo 'Oh dear! Broken!';
}
elseif (\$rows === 0)
{
echo 'No rows :(';
}
elseif (\$rows > 0)
{
echo 'There are '.\$rows.' rows!';
}
else
{
}
``````

## Here comes null

So, this is where it might start to mess with your mind.

0 is still a number, it has a value (even though the value is nothing). `false` has a value, it means “off”, it’s the opposite of `true`.

To define a variable as being nothing, you use `null`.

Null is shared across many languages, not just PHP. A MySQL database will recognise `null`.

There is a forth part to this love triangle. So it’s sort of a square really. There is the empty string.

``````\$var = '';
``````

If you echo that in PHP, you’ll get nothing. But, it’s still a string. It’s an empty string. That’s different to `false`, 0 and `null`.

And that’s why we have `null`, to tell the difference between an empty string and “nothing”.

`null` is equal to `false`, 0 and an empty string.

``````\$var1 = 0;
\$var2 = '0';
\$var3 = '';
\$var4 = false;
\$var5 = null;
``````

If you compare any of those using the equal operator `==` they will all match each other.

But if you use the identical operator `===`, they will fail.

To test for `null`, PHP has a function `is_null`, which returns a boolean – that means that it’ll return `true` or `false`.

Null is most useful when using databases, as rather than storing an empty string for an optional field, you can store a `null` value. This can be used for error prevention and security amongst other things. It’s also much quicker for a database to select rows using `null` values, rather than empty strings.

Some databases don’t even let you have empty strings!

## Everything is true

If you use `false` or `null` as a string, it’ll always return as being `true` or as a string.

``````\$var1 = "null";
``````

That’s a string for the word “null”, not the value `null`. That’ll equal `true`.

## isset

So I said that all those variables above are equally comparable. There is one function that ignores this, which is `isset`. This’ll tell you if a variable is set or not. It returns `false` if the variable is null. This is useful when displaying data, so that you don’t try and echo something that doesn’t exist and get a notice error.

## empty

`empty` is the opposite to `isset`, and includes `null`. Using `empty(\$var)` will return `true` if the variable is any of the following:

• ” (empty string)
• 0
• ‘0’
• `null`
• `false`

## Notes

It should be noted that I’ve used `null` and `true` in lowercase letters. There is a lot of debate to whether you use uppercase `TRUE` or lowercase `true`, but actually it doesn’t matter. The PHP manual always refers to them in uppercase, but most coding style guides prefer lowercase as it’s much easier to read. The most important thing, as with many similar things, is to retain continuity across a project.

Hopefully that explains a bit more about 0, `false`, `null` and empty strings.