Question

I use the following code currently

if (oldValue) ...

It works well in case oldValue is null, but in case it is 0, it also returns false, when I expect true. So, how should I check for null value? I was thinking about

if (oldValue!=null) ...

but it doesn’t work as I’ve expected.

Answer 1

To answer your question directly, if your allowed values are 0 and 1 the if statement should look like:

if (0 === oldValue || 1 === oldValue) {
     ...
}

This is (in my opinion) the clearest way to state which values are allowed.

For a more details explanation see below:

---

This has to do with truthy and falsy values.

null evaluates to false, as do 0, "", undefined and NaN, these are called falsy values.

Likewise, some values evaluate to true. Such as: "a string", "0" (non empty string “0”), any number other than 0 (including negative numbers), Arrays and Objects (even empty ones). These are truthy values.

There are some unexpected results:

"" == false     // true
0 == false      // true

but:

NaN == false    // false
null == false   // false

In practice you should always use the identity operator === instead of equality (==). This ensures that you know what type your variable is expected to be (String, Number, Object) and what the exceptional states are.

Some examples:

• If you’re getting a value from an input field it will always be a string – the special case is the empty string. Coincidentally this is a falsy value.
• If you’re counting elements and you need to do something special in case there are no elements – the special case is 0. Coincidentally this is a falsy value.
• If you’re trying to parse a number from a string using parseInt or parseFloat – the special case NaN (check with isNaN()). Coincidentally this is a falsy value.
• If you’re checking if a substring occurs within a string using indexOf – the special case is -1 (because 0 is a valid index). This is not a falsy value, but if(str.indexOf(substr)) is most certainly wrong because it is unclear the author knows about the possibly allowed value 0 (which is falsy)

The point here is: the special cases usually are well defined. Harnessing that allows you to always use the identity operator ===. The equality operator == and falsiness is a common source of bugs.

For reference:

"" === false    // false
0 === false     // false
NaN === false   // false
null === false  // false
false === false // true (of course)
NaN === NaN     // strange, but makes sense
"a" === "a"     // yay!