Boolean Values in JavaScript

It is often useful to have a value that distinguishes between only two possibil­ities, like “yes” and “no” or “on” and “off.” For this purpose, JavaScript has a Boolean type, which hasjust two values, true and false, which are written as those words.


Here is one way to produce Boolean values:

console.log(3 > 2) // → true

console.log(3 < 2) // → false

The > and < signs are the traditional symbols for “is greater than” and “is less than,” respectively. They are binary operators. Applying them results in a Boolean value that indicates whether they hold true in this case.

Strings can be compared in the same way.

console.log(“Aardvark” < “Zoroaster”)

// → true

The way strings are ordered is roughly alphabetic but not really what you’d expect to see in a dictionary: uppercase letters are always “less” than lowercase ones, so “Z” < “a”, and nonalphabetic characters (!, -, and so on) are also included in the ordering. When comparing strings, JavaScript goes over the characters from left to right, comparing the Unicode codes one by one.

Other similar operators are >= (greater than or equal to), <= (less than or equal to), == (equal to), and != (not equal to).

console.log(“Itchy” != “Scratchy”)
console.log(“Apple” == “Orange”)
// →

There is only one value in JavaScript that is not equal to itself, and that is NaN (“not a number”).

console.log(NaN == NaN)

// → false

NaN is supposed to denote the result of a nonsensical computation, and as such, it isn’t equal to the result of any other nonsensical computations.

Logical Operators

There are also some operations that can be applied to Boolean values them­selves. JavaScript supports three logical operators: and, or, and not. These can be used to “reason” about Booleans.

The && 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

The || 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—!true produces false, and false gives true.

When mixing these Boolean operators with arithmetic and other oper­ators, it is not always obvious when parentheses are needed. In practice, you can usually get by with knowing that of the operators we have seen so far, || has the lowest precedence, then comes &&, then the comparison operators (>, ==, and so on), and then the rest. This order has been chosen such that, in typical expressions like the following one, as few parentheses as possible are necessary:

1 + 1 == 2 && 10 * 10 > 50

The last logical operator I will discuss is not unary, not binary, but ternary, operating on three values. It is written with a question mark and a colon, like this:

console.log(true ? 1 : 2);

// → 1

console.log(false ? 1 : 2);

// → 2

This one is called the conditional operator (or sometimes just the ternary operator since it is the only such operator in the language). The value on the left of the question mark “picks” which of the other two values will come out. When it is true, it chooses the middle value, and when it is false, it chooses the value on the right.

Source: Haverbeke Marijn (2018), Eloquent JavaScript: A Modern Introduction to Programming,

No Starch Press; 3rd edition.

Leave a Reply

Your email address will not be published. Required fields are marked *