// Outputs "Infinity" console.log(Infinity) // Outputs "Infinity" console.log(Infinity - 1) // Outputs "-Infinity" console.log(-Infinity) // Outputs "NaN" even though // "NaN" is a value of the number type console.log(0 / 0) console.log(Infinity - Infinity) console.log(Number('blah'))
Operators that use two values are called binary operators, while those that take one are called unary operators. The minus operator can be used both as a binary operator and as a unary operator.
// Output is -8 and this includes // a unary operator and binary operator // (the two - symbols) console.log(-(10 - 2)) // Another unary operator // which does output of "string" console.log(typeof "blah")
&& operator represents logical and. It is a binary operator, and its result is true only if both the values given to it are true.
console.log(true && false) // false console.log(true && true) // true
|| operator denotes logical or. It produces true if either of the values given to it is true.
console.log(false || true) // true console.log(false || false) // false
Not is written as an exclamation mark (
!). It is a unary operator that flips the value given to it—
console.log(!true) // false console.log(!false) // true
The last logical operator I will discuss is not unary, not binary, but ternary, operating on three values. This one is called the conditional operator (or sometimes just the ternary operator since it is the only such operator in the language). When it is true, it chooses the middle value, and when it is false, it chooses the value on the right.
console.log(true ? 1 : 2); // 1 console.log(false ? 1 : 2); // 2
var a console.log(a) // undefined
null is an assignment value. It can be assigned to a variable as a representation of no value.
var a = null console.log(a) // null
Testing some things about
console.log(typeof null) // object console.log(typeof undefined) // undefined console.log(null === undefined) // false console.log(null == undefined) // true console.log(null === null) // true console.log(null == null) // true console.log(!null) // true console.log(null) // null console.log(!!null) // false because false is opposite // of true as console.log(!null) evaluates to true console.log(1 + null) // 0 (number) console.log(1 + undefined) // NaN
Automatic type conversion
null in the first expression becomes
0, and the
"5" in the second expression becomes
5(from string to number). Yet in the third expression,
+ tries string concatenation before numeric addition, so the
1 is converted to
"1" (from number to string).
When something that doesn’t map to a number in an obvious way (such as
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(8 * null) // 0 console.log("5" - 1) // 4 console.log("5" + 1) // "51" console.log("five" * 2) // NaN console.log(false == 0) // true console.log(null == undefined); // true console.log(null == 0); // false
Short-circuiting of logical operators
The logical operators
|| 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.
|| 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