There are two separate issues with 'falsey' values in JavaScript.

Firstly there is the official conversion scheme, which is what is returned by Boolean(x). This returns false when x is false or 0 or NaN or null or undefined or "" and true otherwise. This is the same behaviour as the

if (condition) {/*true path*/} else {/*false path*/}

that is, the false path is executed if Boolean(condition) would have returned false and the true path is executed otherwise. This behaviour is often used to check to see if a property is defined. However, doing that is not safe unless you are certain that the property would be an object or an array if it is defined. The safest way to test if a property is defined is to do

if (property != null) { /*property is defined*/} 

which makes sure that the property is not null or undefined. If you only want to make sure the property is not undefined do

if (property !== undefined) { /*property is not undefined (but may be null)*/ } 

(notice the extra = in !==).

Secondly, there are all the values that == false. This is everything that can be coerced to 0 (which is what false gets coerced to). This includes all the values that convert to false except NaN (which can't == false by virtue of it never == anything), null and undefined. But it also includes all objects that when converted to a string and then converted to a number are equal to 0. For example, this includes everything that when converted to a string is either the empty string "" or "0" or "-0" or "+0" or "0x00" or "000" or "0e0" or "0.0000"...., for example,

({toString: function() {return "-00.0e000";}}) == false

is true. Interestingly, this includes the empty array, and any nesting of arrays containing only a single other item that returns an empty or 0 string since arrays rendered as strings show only the contents without the surrounding brackets. That is,

[[[[0]]]] == false; // Because [[[[0]]]].toString() === "0"
[] == false;
[[[""]]] == false;
["0"] == false;
[[({toString: function() {return "0";}})]] == false;

The full algorithm for calculating == false is described here.

The reason this matters is because it can lead to subtle, difficult to find bugs if you don't understand most of these rules. Most important takeaways are probably how the if (condition) works and that using === avoids most of the other crazy stuff.

You can check for falsy values using

var n = null;
if (!n) {
    console.log('null');
} else {
    console.log('has value');
}

Demo: Fiddle

Or check for truthiness like

var n = null;
if (n) { //true if n is truthy
    console.log('has value');
} else {
    console.log('null');
}

Demo: Fiddle