Course: JavaScript

Progress (0%)

JavaScript Booleans

Chapter 21 16 mins

Learning outcomes:

  1. What are Booleans
  2. How to create Booleans
  3. Conversion to a Boolean using Boolean() and !!
  4. Boolean conversion rules

What are Booleans?

In computer programming, Booleans are true or false values that sit at the heart of conditional programming, executing code based on given conditions.

There are thousands of instances in programming where we need to perform certain actions once certain conditions are met.

As an example, read the following sentence: 'If it is raining outside, take an umbrella.' The condition here is: 'it is raining' and the action to be taken if the condition is met is: 'to take an umbrella'.

As another example, more relevant to us computer users, consider the following: 'If the battery is low, automatically switch off the computer.' Again you have a condition, 'the battery is low', and an action, 'switch off the computer'.

And there can be many such examples operating on the same idea — the fullfilment of a condition dictating an action.

In computers, we use Booleans to check whether some condition is met or not. All programming languages follow the same principles of Boolean and thus make conditional programming fairly consistent.

What does 'Boolean' mean?

The name 'Boolean' is given in honour of the prolific English mathematician, George Boole, based on his contributions to the mathematical discipline of Boolean algebra.

Let's now see how to create Booleans in JavaScript.

Creating Booleans

As with numbers and strings, we can create Booleans in JavaScript using literal notation.

The Boolean literals are true and false.

As we learnt in the previous part of this course, just like number literals create number primitives and string literals create string primitives, Boolean literals create ... you're right ... Boolean primitives.

Remember, both of these literals true and false are keywords in JavaScript.

In the code below, we create two variables and assign them Boolean values:

var isRainyDay = true;
var isBatteryLow = false;

An important thing to note here is the naming of the variables, starting with the word 'is'.

It's a good practice to begin the names of identifiers holding Booleans with the words 'is', 'has', or just name them after past-tense verbs. This helps us right away understand the purpose of these identifiers in the source code.

For example, isBatteryLow, isRainyDay, isExecuted (or even executed), isOK, hasAuthority, collapsed, defaultPrevented, are all examples of good names for identifiers holding Booleans.

Try NOT to name Boolean identifiers as verbs, such as run. Verbs go best with functions and methods, remember?

However, it's important to keep in mind that this isn't a hard-and-fast rule to follow; we might as well not use it on certain occasions. For instance, we're better off at naming a variable ok rather than isOK to indicate whether a particular operation in a program went alright or not.

Anyways, moving on, to check whether an arbitrary value is a Boolean, we can use the typeof operator. When used on a Boolean primitive, typeof returns the string 'boolean':

var isRainyDay = true;
var isBatteryLow = false;

console.log(typeof isRainyDay);
console.log(typeof isBatteryLow);
boolean boolean

Following is a quick task for you.

Create two Boolean variables isSubmitted and error, and assign them both a falsey Boolean value.

The term 'falsey' simply means to give the variables the value false. Following is the code that accomplishes the task above:

var isSubmitted = false;
var error = false;

Since Booleans are also a primitive type of JavaScript, we can create them using constructors as well. However, this is clearly NOT recommended ever in code.

Read on below to get a quick review on this notion.

The Boolean() constructor

As with the number and string data types in JavaScript, Booleans can also be created as objects. This requires the Boolean() constructor.

Following, we create two Boolean objects:

var isRainyDay = new Boolean(true);
var isBatteryLow = new Boolean(false);

If we inspect these values using the typeof operator, we'll get 'object' returned simply because they are objects:

var isRainyDay = new Boolean(true);
var isBatteryLow = new Boolean(false);

console.log(typeof isRainyDay);
console.log(typeof isBatteryLow);
object object

Despite the fact that the Booleans here are created using a constructor, we have to provide the literals true or false anyways. So, there's really no benefit of using new Boolean(), and we even shouldn't!

Now if you're thinking of the purpose of the Boolean() constructor and Boolean objects in JavaScript, know that it's the same as the purpose of the Number() and the String() constructors.

That is, the Boolean() constructor is meant to be called automatically, internally by the JavaScript engine when the need be, for the purpose of autoboxing (remember this?).

To learn more about this, consider the following sections from this course:

Re-emphasizing on it, never ever use new Boolean() in your code! It makes code verbose and ugly, and is not even meant to be used manually.

Things to note

  1. All relational operators return Booleans, always:

    typeof (1 == 1)
    typeof (1 < 2)
    typeof (1 > 2)
    typeof (1 === 1)
  2. Logical operators return Booleans depending on the operator, the operands, and the order of the operands:

    For example, consider the following:

    true && 1
    1 && true

    true && 1 yields 1 while the same operator called on the same values only with the order of the values changed, in 1 && true, returns true. Recall that this happens because of the way && works.

    In particular, && evaluates it first operand and returns it if it's falsey, otherwise returns the second operand.

    Another example follows of &&:

    null && false
    false && null

    In null && false, since the first operand null is falsey, it gets returned right away. So is the case with false && null, whereby false gets returned rightaway.

Converting to Boolean

While developing JavaScript programs, there'll be a multitude of instances where we'll want to go from a given data type to a Boolean. In this section, we'll see how to do just that.

There are mainly two ways for converting a value into a Boolean:

  • Using the Boolean() function (not the constructor)
  • Using double negation (!!)

Let's start with the first one.

The Boolean() function

The Boolean() function, when called with an arbitrary value, returns back its corresponding Boolean equivalent (based on rules which we shall see in the next section).

Consider the code below where we convert a string into a Boolean:

var str = 'Hello World!';
var strBool = Boolean(str);


As we shall see shortly below, a non-empty string always gets converted to a truthy Boolean, likewise strBool here holds the value true.

Double negation (!!)

Recall the negation operator (!) from the JavaScript Operators chapter? It negates its given operand and returns back a Boolean.

A naive idea to use this operator for converting a value into a Boolean is to use the operator twice, hence the name double negation.

In the first instance, it returns a negated Boolean; in the second instance, it negates this negated value to get back the initial Boolean value.

What an elegant approach.

Following we rewrite the code above using Boolean() to instead use !!:

var str = 'Hello World!';
var strBool = !!(str);


As expected, the result is the same — true.

Now deciding between which of these should you use, well it's more about preference. If you like Boolean(), go with it. If you like !! more, probably because it's easier to type, go with it.

Whatever you choose, just make sure to remain consistent with it throughout your JavaScript programs. The last thing you want in your code is to have a mix of Boolean() and !!.

Boolean conversion rules

In this respect, it's worthwhile understanding the rules of converting given values into Booleans in JavaScript.

This is important because different languages usually have different conversion rules, and we must be aware of these rules in order to make sure that we know how our programs interact and execute.

Rules for numbers

All numbers except for 0 and NaN get converted to the Boolean value true. The numbers 0 and NaN get converted to false. Quite basic, ain't it?


Rules for strings

All strings except for the empty string ('', "", ``) get converted to true. The empty string gets converted to false:

Boolean(' ')

Rules for undefined and null

Expectedly, both undefined and null convert to the Boolean false:


Rules for objects

It's very easy with converting objects in JavaScript to Booleans — every object gets converted to true, even the one without any properties:

Boolean({ x: 0 })
Boolean(new Boolean(false))

Notice the last statement here: we're converting a Boolean object with the value false into a Boolean (primitive). One might expect that since the object wraps the value false, its conversion would yield false. However, that's NOT the case.

The reason isn't hard to understand. new Boolean(false) returns an object and because all objects convert to true, this one converts to true as well.

"I created Codeguage to save you from falling into the same learning conundrums that I fell into."

— Bilal Adnan, Founder of Codeguage