A Boolean only ever holds one of two values.

let isLoggedIn = true;
let hasPermission = false;

console.log(typeof isLoggedIn); // "boolean"

Comparison and logical operators naturally return booleans too, so you'll see this type constantly even if you're not creating it directly.

console.log(5 > 3);        // true
console.log(10 === "10");  // false
console.log(5 !== 4);      // true

 

Truthy and Falsy: The Part That Confuses Everyone

Here's where it gets interesting. JavaScript doesn't require an actual true or false to make a decision in something like an if statement. It just checks whether a value counts as "truthy" or "falsy."

There are only a handful of falsy values in the entire language, and it's genuinely worth memorizing all of them:

false
0
-0
""
null
undefined
NaN

That's it. Every single other value, no matter how strange it looks, counts as truthy.

if ("hello") {
  console.log("This runs, because a non-empty string is truthy");
}

if (0) {
  console.log("This never runs, because 0 is falsy");
}

 

The Surprises That Catch People Off Guard

This is the part that genuinely trips up even experienced developers. An empty array and an empty object are both truthy, even though they feel like they should mean "nothing."

if ([]) {
  console.log("This runs! An empty array is truthy.");
}

if ({}) {
  console.log("This runs too! An empty object is truthy.");
}

The string "0" is also a common trap. It looks like it should behave like the number 0, but it's a non-empty string, so it's truthy.

if ("0") {
  console.log("This runs, because '0' is a non-empty string.");
}

Keep an eye out for these specifically, they're some of the most common sources of quiet bugs in real code.
 

Converting Values to an Actual Boolean

Sometimes you want to explicitly convert a value into a real true or false, rather than just relying on truthy or falsy behavior inside a condition. There are two common ways to do this.

console.log(Boolean("hello")); // true
console.log(Boolean(0));       // false
console.log(Boolean(null));    // false

console.log(!!"hello"); // true
console.log(!!0);       // false

That double exclamation mark, !!, is a common shorthand. The first ! flips the value to its opposite boolean, and the second ! flips it right back, leaving you with a clean, actual boolean instead of just a truthy or falsy value.
 

Conclusion

Boolean itself is genuinely the simplest type in JavaScript, it's really the truthy and falsy behavior around it that deserves your attention. Once you've actually memorized that short list of falsy values, a surprising number of confusing bugs, especially ones involving empty arrays, empty objects, and the string "0", stop being mysterious and start making complete sense.
 

Frequently Asked Questions (FAQs)

1.Why is an empty array truthy if it technically contains nothing?

Because JavaScript's falsy list is a short, fixed set of specific values, and arrays and objects simply aren't on it, no matter how empty they look. Only the values in that list count as falsy.

2.What's the difference between Boolean(value) and !!value?

They do the exact same thing, convert a value into an actual true or false. Boolean() is more explicit and readable, while !! is a shorter, commonly used shorthand you'll see often in real code.

3.Is NaN truthy or falsy?

Falsy. It's one of the seven specific falsy values in JavaScript, even though it represents an invalid number rather than an empty or zero-like value.