console.log(8 * null)
// → 0
console.log(“5” – 1)
// → 4
console.log(“5” + 1)
// → 51
console.log(“five” * 2)
// → NaN
console.log(false == 0)
// → true
When something that doesn’t map to a number in an obvious way (such as “five” or undefined) is converted to a number, you get the value NaN. Further arithmetic operations on NaN keep producing NaN, so if you find yourself getting one of those in an unexpected place, look for accidental type conversions.
console.log(null == undefined);
// → true
console.log(null == 0);
// → false
That behavior is often useful. When you want to test whether a value has a real value instead of null or undefined, you can compare it to null with the == (or !=) operator.
But what if you want to test whether something refers to the precise value false? Expressions like 0 == false and “” == false are true. When you do not want any automatic type conversions to happen, there are two additional operators: === and !==. The first tests whether a value is precisely equal to the other, and the second tests whether it is not precisely equal. So “” === false is false as expected.
I recommend using the three-character comparison operators defensively to prevent unexpected type conversions from tripping you up. But when you’re certain the types on both sides will be the same, there is no problem with using the shorter operators.
Short-Circuiting of Logical Operators
The logical operators && and || handle values of different types in a peculiar way. They will convert the value on their left side to Boolean type in order to decide what to do, but depending on the operator and the result of that conversion, they will return either the original left-hand value or the right- hand value.
The || operator, for example, will return the value to its left when that can be converted to true and will return the value on its right otherwise. This has the expected effect when the values are Boolean and does something analogous for values of other types.
console.log(null || “user”)
// → user
console.log(“Agnes” || “user”)
// → Agnes
We can use this functionality as a way to fall back on a default value.
If you have a value that might be empty, you can put || after it with a replacement value. If the initial value can be converted to false, you’ll get the replacement instead. The rules for converting strings and numbers to Boolean values state that 0, NaN, and the empty string (“”) count as false, while all the other values count as true. So 0 || -1 produces -1, and “” || “!?” yields “!?”.
The && operator works similarly but the other way around. When the value to its left is something that converts to false, it returns that value, and otherwise it returns the value on its right.
Another important property of these two operators is that the part to their right is evaluated only when necessary. In the case of true || X, no matter what X is—even if it’s a piece of program that does something terrible—the result will be true, and X is never evaluated. The same goes for false && X, which is false and will ignore X. This is called short-circuit evaluation.
The conditional operator works in a similar way. Of the second and third values, only the one that is selected is evaluated.
No Starch Press; 3rd edition.