JavaScript Comparisons: === vs ==, Truthy and Falsy Values

Conditions are built from comparisons, so it is important to know exactly how JavaScript compares values. This lesson covers the two kinds of equality and the idea of truthy and falsy values.

=== versus ==#

Strict equality === is true only when the values have the same type and the same value. Loose equality == converts the types first, using complicated rules:

console.log(5 === 5);
console.log(5 === "5");
console.log(5 == "5");
console.log(0 == "");
console.log(0 == "0");
console.log("" == "0");
console.log(null == undefined);
console.log(null === undefined);

true
false
true
true
true
false
true
false

0 == "" and 0 == "0" are both true, but "" == "0" is false: loose equality is not even consistent with itself. Always use === and !==. The one common exception is value == null, a deliberate shortcut that is true for both null and undefined.

Comparing numbers and strings#

<, >, <= and >= compare numbers numerically and strings alphabetically, character by character (by Unicode code):

console.log(10 > 9);
console.log("10" > "9");
console.log("apple" < "banana");
console.log("Zebra" < "apple");

true
false
true
true

"10" > "9" is false because, as text, "1" comes before "9". Uppercase letters come before lowercase ones in Unicode, so "Zebra" < "apple". Convert to numbers or use localeCompare (Strings) when the order matters.

Comparing objects#

Objects and arrays are compared by reference: two different objects are never equal, even with the same contents:

const a = { id: 1 };
const b = { id: 1 };
const c = a;

console.log(a === b);
console.log(a === c);
console.log([1, 2] === [1, 2]);

false
true
false

To compare contents, compare the properties you care about (a.id === b.id), or for simple data, compare JSON.stringify(a) === JSON.stringify(b) (which depends on property order).

NaN and Object.is#

console.log(NaN === NaN);
console.log(Number.isNaN(NaN));
console.log(Object.is(NaN, NaN));
console.log(Object.is(0, -0), 0 === -0);

false
true
true
false true

Object.is is like === but treats NaN as equal to itself and distinguishes 0 from -0. You rarely need it; Number.isNaN is the usual check.

Truthy and falsy#

When a value is used as a condition (in if, while, &&, || or !), JavaScript converts it to a boolean. There are exactly eight falsy values:

Everything else is truthy, including "0", "false", " " (a space), [] (an empty array), {} (an empty object) and every function.

const values = [0, "0", "", " ", [], {}, null, "false"];
for (const v of values) {
  console.log(JSON.stringify(v), v ? "truthy" : "falsy");
}

0 falsy
"0" truthy
"" falsy
" " truthy
[] truthy
{} truthy
null falsy
"false" truthy

Checking for empty values safely#

Truthiness is convenient, but it can treat valid values like 0 as missing:

const quantity = 0;

if (!quantity) {
  console.log("Using truthiness: quantity looks missing");
}
if (quantity === undefined || quantity === null) {
  console.log("Never printed: 0 is a real value");
} else {
  console.log("Explicit check: quantity is", quantity);
}

Using truthiness: quantity looks missing
Explicit check: quantity is 0

Practice#

const values = [0, "", null, false, undefined, "hello"];
for (const v of values) {
  console.log(String(v).padEnd(10), v == null ? "missing" : "present");
}

0          present
           present
null       missing
false      present
undefined  missing
hello      present

Key takeaway#