This article provides an overview of truthy and falsy values and how to convert values into booleans in JavaScript.

JavaScript Truthy and Falsy Values Cheatsheet

Boolean(false);         // false
Boolean(undefined);     // false
Boolean(null);          // false
Boolean('');            // false
Boolean(NaN);           // false
Boolean(0);             // false
Boolean(-0);            // false
Boolean(0n);            // false

Boolean(true);          // true
Boolean('hi');          // true
Boolean(1);             // true
Boolean([]);            // true
Boolean([0]);           // true
Boolean([1]);           // true
Boolean({});            // true
Boolean({ a: 1 });      // true

It's best to start by first understanding which values are interpreted as truthy or falsy by JavaScript. It's also important to understand implicit coercion compared to explicit coercion.

Implicit coercion is initiated by the JavaScript engine and happens automatically. Explicit coercion is performed by manually converting values, and JavaScript provides built in methods to handle this.

The !! Operator

!!value

You may already be familiar with ! as the logical NOT operator. When using two in succession (!!), the first ! coerces the value to a boolean and inverts it. For example !true would result in false. The second ! reverses the previous inverted value, resulting in the true boolean value.

This is generally a preferred method, as it has better performance. A potential con to this method is a loss in readability, mainly if other developers are unfamiliar with how this operator works.

const value = "truthy string"
!!value // true

Here is an example breaking this down into steps:

const value = "truthy string";

!value; // false
!!value; // true

Below is a list of example output with the !! operator.

// Falsy Values

!!'' // false
!!false // false
!!null // false
!!undefined // false
!!0 // false
!!NaN // false


// Truthy Values

!![] // true
!!"false" // true
!!true // true
!!1 // true
!!{} // true

The Boolean() Function

Boolean(value)

Boolean() is a global function that converts the value it's passed into a boolean.

You shouldn't use this with the new keyword (new Boolean) as this creates an instance of a Boolean that has a type of object. Below is an example of the correct use of this function.

const value = "truthy string"
Boolean(value) // true

TL;DR

There are two methods to cast a value to a boolean in JavaScript.

1. !!

!!value

2. Boolean()

Boolean(value)

const finalThoughts = "I really enjoyed writing this article. Thanks for reading!"

!!finalThoughts // true
Boolean(finalThoughts) // true

Boolean gets its name from the English mathematician, George Boole.

Boole created a new branch of algebra, now known as Boolean Algebra, where the value of true is 1 and the value of false is 0. In Boolean Algebra, there are three main logical operations: AND, OR, and NOT.

Boolean Algebra laid the foundation for the information age and computer science. All computers function using the basic principles of Boolean Algebra, where 1, or true, is on, and 0, or false, is off.

Because of this, many programming languages include boolean data types and operators.

For example, in JavaScript, it's common to see the boolean data types true and false:

const isCat = true;

JavaScript also has logical operators for AND:

const isCat = true;
const isCute = true;

if (isCat && isCute) { // isCat AND isCute are both true
  console.log("There's a cute cat :D"); // logs "There's a cute cat :D" to the console
}

OR:

const isCat = true;
const isFluffy = false;

if (isCat || isFluffy) { // either isCat OR isFluffy are true
  console.log("There's an animal that might be a cat, fluffly, or both"); // logs "There's an animal that might be a cat, fluffly, or both" to the console
}

And NOT:

const isCat = true;
const isFluffy = false;

if (!isFluffy) { // isFluffy is false, or NOT true
  console.log("Whatever this animal is, it's not fluffy"); // logs "Whatever this animal is, it's not fluffy" to the console
}

Also, like many other programming languages, JavaScript has other operators that return a boolean value:

const catName = 'Boomer';

if (catName === 'Boomer') { // evaluates to true
  console.log('BOOMER LIVES!'); // logs 'BOOMER LIVES!' to the console
}

Related Tech Terms:

• Binary Definition
• Bit Definition

We all love computers. They can do so many amazing things. Within a couple of decades computers have completely revolutionized almost all the aspects of human life.

They can do tasks of varying degrees of sophistication, all by just flipping zeros and ones. It is remarkable to see how such a simple action can lead to so much complexity.

But I'm sure you all know that such complexity cannot be achieved (practically) by just randomly flipping the numbers. There is indeed some reasoning behind it. There are rules that govern the way this should be done. In this article we will discuss those rules and we will see how they govern the way computers "think".

What is Boolean Algebra?

The rules I mentioned above are described by a field of Mathematics called Boolean Algebra.

In his 1854 book, British Mathematician George Boole proposed a systematic set of rules for manipulation of Truth Values. These rules gave a mathematical foundation for dealing with logical propositions. These sets of foundations led to the development of Boolean Algebra.

To best understand Boolean Algebra, we first have to understand the similarities and differences between Boolean Algebra and other forms of Algebra.

Algebra, in general, deals with the study of mathematical symbols and the operations that can be performed on these symbols.

These symbols do not have a meaning of their own. They represent some other quantity. It is this quantity that gives some value to these symbols and it is this quantity on which the operations are actually being performed.

Boolean Algebra also deals with symbols and the rules that govern the operations on these symbols but the difference lies in what these symbols represent.

In case of ordinary Algebra, the symbols represent the Real numbers whereas in Boolean Algebra they represent the Truth values.

The image below shows the entire set of Real numbers. The set of Real numbers includes Natural numbers(1, 2, 3, 4....), Whole numbers (all the Natural numbers and 0), Integers (.....-2, -1, 0, 1, 2, 3 ...) and so on. Ordinary Algebra deals with this entire set of numbers.

The Truth values, in comparison, consist of a set of only two values: False and True. Here, I would like to point out the fact that we can use any other symbol to represent these values.

For example in Computer Science we mostly represent these values using 0 and 1. 0 is used for False and 1 for True.

You can also do it in more fancy ways by representing truth values with some other symbols such as Cats and Dogs or Bananas and Oranges.

The point here is that the internal meaning of these symbols will remain the same irrespective of the symbol you use. But make sure that you don't change the symbols while performing the operations.

Now the question is that if (True and False), (0 and 1) are just the representations, then what is it that they are trying to represent?

The underlying meaning behind truth values comes from field of Logic where truth values are used to tell if a proposition is "True" or "False". Here the truth values represent the relation of a proposition to truth, that is, whether the proposition is true or false.

A proposition is just a statement like "All cats are cute."

If the above proposition is true then we assign it the truth value of "True" or "1" otherwise we assign it "False" or "0".

In Digital Electronics, truth values are used to represent the "On" and "Off" states of electronic circuits. We will discuss more about that later in this article.

Boolean Operations and Truth Tables

Just like Ordinary Algebra, Boolean Algebra also has operations which can be applied on the values to get some results. Although these operations are not similar to ones in ordinary algebra because, as we discussed earlier, Boolean algebra works on Truth values rather than Real Numbers.

Boolean Algebra has three basic operations.

OR: Also known as Disjunction. This operation is performed on two Boolean variables. The output of the OR operation will be 0 when both of the operands are 0, otherwise it will be 1.

To get a clearer picture of what this operation does we can visualize it with the help of a Truth Table below.

Truth tables give us an insightful representation of what the Boolean operations do and they also act as a handy tool for performing Boolean operations.

        OR Operation

Variable-1    Variable-2    Output
  0        0        0
  0        1        1
  1        0        1
  1        1        1

AND: Also known as Conjunction. This operation is performed on two Boolean variables. The output of AND operations will be 1 when both operands are 1, otherwise it will be 0. The truth table representation is as follows.

        AND Operation

Variable-1    Variable-2    Output
  0        0        0
  0        1        0
  1        0        0
  1        1        1

NOT: Also known as Negation. This operation is performed only on one variable. If the value of the variable is 1 then this operation simply converts it into 0 and if the value of the variable is 0, then it converts it into 1.

    Not Operation

Variable-1    Output
  0        1    
  1        0

Boolean Algebra and Digital Circuits

After its initial development, Boolean Algebra, for a very long time, remained one of those concepts in Mathematics which did not have any significant practical applications.

In the 1930s, Claude Shannon, an American Mathematician, realised that Boolean Algebra could be used in circuits where the binary variables could represent the "low" and "high" voltage signals or "on" and "off" states.

This simple idea of making circuits with the help of Boolean Algebra led to the development of Digital Electronics which contributed heavily in the development of circuits for computers.

Digital Circuits implement Boolean Algebra with the help of Logic Gates. Logic Gates are the circuits which represent a boolean operation. For example an OR gate will represent an OR operation. The same goes for NOT and AND gates as well.

Alongside the basic logic gates we also have logic gates that can be created using the combination of the basic logic gates.

NAND: NAND gate is formed by a combination of the NOT and AND gates. NAND gate gives an output of 0 if both inputs are 1, otherwise 1.

NAND gate holds the property of Functional Completeness, which means that any boolean function can be implemented just by using a combination of NAND gates only.

        NAND Gate

Variable-1    Variable-2    Output
  0        0        1
  0        1        1
  1        0        1
  1        1        0

NOR: NOR gate is formed by a combination of NOT and OR gates. NOR gate gives an output of 1 if both inputs are 0, otherwise 0.

NOR gate, just like NAND gate, holds the property of Functional Completeness, which means that any boolean function can be implemented just by using a combination of NOR gates only.

        NOR Gate

Variable-1    Variable-2    Output
  0        0        1
  0        1        0
  1        0        0
  1        1        0

Most digital circuits are built using NAND or NOR gates because of their functional completeness property and also because they are easy to fabricate.

Other than the above mentioned gates we also have some special kind of gates which serve some specific purpose. These are as follows:

XOR: XOR gate or Exclusive-OR gate is a special type of logic gate which gives 0 as output if both of the inputs are either 0 or 1, otherwise it gives 1.

        XOR Gate

Variable-1    Variable-2    Output
  0        0        0
  0        1        1
  1        0        1
  1        1        0

XNOR: XNOR gate or Exclusive-NOR gate is a special type of logic gate which gives 1 as output when both the inputs are either 0 or 1, otherwise it gives 0.

        XNOR Gate

Variable-1    Variable-2    Output
  0        0        1
  0        1        0
  1        0        0
  1        1        1

Conclusion

So, with all that we can now conclude our discussion on Boolean Algebra here. I hope by now you have a decent picture of what Boolean Algebra is all about.

This is definitely not all you need to know about Boolean Algebra. Boolean Algebra has a lot of concepts and details that we were not able to discuss in this article.

true.class
 => TrueClass
false.class
 => FalseClass
nil.class
 => NilClass

true and false are Ruby’s native boolean values. A boolean value is a value that can only be one of two possible values: true or not true. The object true represents truth, while false represents the opposite. You can assign variables to true / false, pass them to methods, and generally use them as you would other objects (such as numbers, Strings, Arrays, Hashes).

nil is a special value that indicates the absence of a value – it is Ruby’s way of referring to “nothing”. An example of when you will encounter the nil object is when you ask for something that doesn’t exist or cannot be found:

hats = ["beret", "sombrero", "beanie", "fez", "flatcap"]

hats[0]
 => "beret" # the hat at index 0
hats[2]
 => "beanie" # the hat at index 2
hats[4]
 => "flatcap" # the hat at index 4
hats[5]
 => nil # there is no hat at index 5, index 5 holds nothing (nil)

Zero is not nothing (it’s a number, which is something). Likewise, empty strings, arrays, and hashes are not nothing (they are objects, which happen to be empty). You can call the method nil? to check whether an object is nil.

0.nil?
 => false
"".nil?
 => false
[].nil?
 => false
{}.nil?
 => false
nil.nil?
 => true
 # from the example above
hats[5].nil?
 => true

Every object in Ruby has a boolean value, meaning it is considered either true or false in a boolean context. Those considered true in this context are “truthy” and those considered false are “falsey.” In Ruby, only false and nil are “falsey,” everything else is “truthy.”

More Information:

• Learning Ruby: From Zero to Hero
• Idiomatic Ruby: writing beautiful code
• How to Export a Database Table to CSV Using a Simple Ruby Script

If you have ever watched a TV show about court (or been to court), then you can understand booleans in JavaScript.

You might think that booleans are the most straightforward topic that you could ask for in JavaScript.

After all, since a variable can be any of the following:

• number
• string
• array
• object
• boolean

…boolean seems to be the easiest.

let bool = true;

let bool= false;

The only two options for a boolean are true or false. And they are used in if() statements to decide which statement should be executed.

if(true){

}

else{

// if value is false, this block runs

}

But here’s the thing. Within if() statements, other variable values can evaluate to true or false. In other words, once the value is used in the if() statement, JavaScript will evaluate whether it is true or false.

For example, do you know if the value 0 is true or false?

This is not a philosophy question. JavaScript has an answer.

Anyways, this happens because JavaScript is a weakly typed language. This means that in the context of an if() statement, it will convert other variable values to true or false in order to run the code. This is known as determining the “truthiness” of a value.

Many other languages are strongly typed, so they will not convert values into true or false.

This may seem a little crazy, but it is actually pretty similar to the way that a judge in the United States determines whether an accused person is innocent or guilty. So, I can explain the way that “truthiness” and true/false works in JavaScript through legal rules that you have seen in “Law and Order” or any other court-based procedural dramas on TV.

For the purposes of this tutorial, imagine that you are a district attorney that is trying to prosecute a person who is accused of stealing a car.

And, you will need to understand the basics of variables in JavaScript to use this tutorial. Let’s get into it!

What is “truthiness” in JavaScript?

In the United States, the criminal law system states that an accused person is “innocent until proven guilty”. That means that the burden lies on the prosecutor (you, in this case) to provide enough evidence to disprove the default assumption that the accused person is innocent.

In fact, the standard of evidence is “beyond a reasonable doubt.” This is consistent across many countries in the world.

When we use if() statements, we are not always going to be able to plug in a variable with a value of true or false. Many times, we must plug in a statement that will be evaluated by JavaScript as true or false.

This is similar to the legal system! Although it is possible that there will be one piece of evidence that makes the “guilty” or “not guilty” verdict obvious, it is also likely that a judge or jury will need to evaluate multiple pieces of evidence and make a decision.

Let’s start with the basics. A true statement is evidence that will lead to the conviction of the accused. A false statement is evidence that will let them walk free. Let’s create a variable called evidence and set it to true.

let evidence = true;

if (evidence){

  convict();

}

else{

  release();

}

convict() and release() are made-up functions. In this case, since evidence is set to true, the judge would convict the car thief. Here’s an interactive diagram of this scenario.

The robber kinda looks like Edward Norton from “The Italian Job”, eh?

Anyways, in real life, it is never this straightforward. Let’s say that you have a killer piece of evidence — fingerprints from the car door. You present that to the judge.

let evidence = "fingerprints";

if (evidence){

  convict();

}

else{

  release();

}

Aha! We only changed the first line, where we declared the variable evidence. And it is now a string rather than a boolean. But guess what? Due to type coercion, JavaScript will evaluate the string as true. Since there is no condition within the if() statement, all strings are true. We would run the convict() function!

Examples of truthiness

Let’s imagine that instead, the evidence variable is set to 0. We run the same if() statement again.

let evidence = 0;

if (evidence){

  convict();

}

else{

  release();

}

In this case, the statement would actually evaluate to false, and our accused car thief would be released.

This is why it is called “truthiness” — because JavaScript is evaluating whether the condition is true or false.

Since the variable is set to 0, it’s kind of like if you were asked to present evidence against the thief, and you said… nothing.

Obviously the judge is going to determine you don’t have enough evidence, and set the person free! The same would happen if evidence was set to an empty string ```. You still aren’t offering anything, so your statement is evaluated asfalse`.

let evidence = '';

Here’s one more test to see if you understand true versus false. What if the variable has not yet been initialized to a value?

let evidence;

if (evidence){

  convict();

}

else{

  release();

}

This is a pretty common one, because web developers will have another statement in their script that gives a value to the evidence variable. And, just like the two examples above, JavaScript will evaluate this variable as false if it does not have any value.

This is a great example of “innocent until proven guilty”. The variable has not yet been assigned a value, so there is no way JavaScript could call it true.

Using DOM Elements in if() statements

So we have covered values of variables that are “falsy”. But what about elements from the DOM?

Note: if you need a refresher, check out my guide to DOM elements here.

In other words, what happens when we use a DOM element to determine which branch of an if/else statement to run? If you use jQuery or React (or Angular, and so forth), you probably manipulate the DOM in order to create a more dynamic interface.

In our courtroom example, let’s say that you swear that the lockpick the thief used is located in a trashcan near the crime scene. In HTML terms, you are saying that there is a div with ID lockpick somewhere in the DOM. How might the judge validate your claim?

if(document.getElementById('lockpick')){

  convict()

}

else{

  release()

}

Here’s an interactive image of that scenario.

“Truthiness” here means that JavaScript will inspect the DOM, and only return true if it finds an element with ID lockpick. It’s kind of like a judge determining if the evidence that you present is real and authentic. In this case, it is, so the first block of code will run, and the person will be convicted.

This is super useful! We have now extended the concept of true so that it includes whether an element exists or not. This logic also applies to objects and arrays. You can check whether an element with a specific class exists, whether a certain element has children, you get the idea.

More variations of if() statements

When you bring an accused person to court, they may still be convicted of a lesser crime. If you don’t have enough evidence for the main charge, they can still be convicted of a lower charges.

In the example of car theft, there is a breaking and entering crime, and then theft is possible if the accused person has already broken into the car.

We can combine if(), else if(), and else() to model these options. Let’s say the accused person did break into the car, but did not take anything. We could model the options like this:

let breaking = true;

let theft = false;

if (breaking && theft){

  convict('felony');

}

else if(breaking){

  convict ('misdemeanor');

}

else{

  release();

}

There are now three scenarios. If the first condition is satisfied, that code block will run. That means that the thief would be convicted of a felony. But, if only the value of the variable breaking can be evaluated as true, the person will still be convicted of a misdemeanor.

The judge is saying, “You need to show me evidence of both breaking and entering and theft if I am going to convict this person of a felony.”

The first if() statement will evaluate true && false, which will be reduced to false since false takes precedence over true (remember, innocent until proven guilty).

This would still work if we used values that were “truthy” or “falsy”. Each one would be evaluated to true or false within the if() statement, and then JavaScript would decide which block to execute.

Get more visual tutorials

Did you enjoy this guide? Give it a “clap”, or sign up below to get my latest tutorials on web development topics.