falsey values in javascript

Question

I had an interesting interview question today that stumped me a little. I was asked about falsey values. So undefined, NAn, Null, 0, an empty string all evaluate to false. What is the reason this is useful to know in javaScript? The only thing I can think of is instead of having to do this:

if(mystring === '' || mystring === undefined) { }

I can do this:

if(!mystring)

Is this the only useful application?

Answer 1

It's useful to detect if a browser is has specific predefined objects:

if(!!navigator.geolocation){
  // executes if the browser has geolocation support
}

if(!!document.createElement('canvas').getContext){
  // executes if the browser supports <canvas>
}

Explanation: navigator.geolocation is an object or undefined. In the case it's an object !navigator.geolocation will return false, if it's undefined it'll return true. So, to check if a browser has geolocation enabled, you want to 'flip' the boolean once more, by adding another !.

Answer 2

It is important to know that 0 evaluates to false to prevent doing things like:

if(str.indexOf('foo'))

Answer 3

They're also useful for setting default values...

function foo(bar){
    alert(bar || "default");
}

I know a lot of people try to do

if (typeof(foo) === "undefined"){}

to get around falsiness, but that's got its own because problems

typeof(null) === "object"

for some reason

Answer 4

It's important to understand how this works in JS, so you're not surprised. Not necessarily just what is falsey, but what is truthy and how they compare to each other.

One example is that '0' is considered equal to 0 with ==, but it is not equal to '' - though 0 is. JavaScript comparison isn't always transitive.

So this means that just because (foo==bar && bar==fizz) is true, (foo==fizz) is not always true. To go with the above example, '0'==0, and 0=='', but '0'!='' - because you're comparing strings in the latter instance, and they're not coerced to booleans.

Answer 5

One dangerous issue of falsey values you have to be aware of is when checking the presence of a certain property.

Suppose you want to test for the availability of a new property; when this property can actually have a value of 0 or "", you can't simply check for its availability using

if (!someObject.someProperty)
    /* incorrectly assume that someProperty is unavailable */

In this case, you must check for it being really present or not:

if (typeof someObject.someProperty == "undefined")
    /* now it's really not available */

Also be aware that NaN isn't equal to anything, even not to itself (NaN != NaN).