JavaScript Booleans

A Boolean is one of JavaScript’s most fundamental data types: it can only ever be one of two values, true or false. Booleans are the backbone of every decision your program makes — every if statement, every loop condition, and every comparison ultimately reduces to a Boolean. Understanding exactly how JavaScript produces and coerces Booleans is essential, because JavaScript is famous for silently converting other types (strings, numbers, objects) into true or false behind the scenes, and that behavior causes a huge share of beginner bugs.

Overview: How Booleans Work

In JavaScript, true and false are reserved keywords that represent the two possible values of the boolean primitive type. Unlike numbers or strings, there is no range of possible values — a Boolean is binary by definition. You can create one directly with a literal, or you can produce one as the result of an operation, most commonly a comparison (>, <, ===, !==, etc.) or a logical operation (&&, ||, !).

Internally, the JavaScript engine treats boolean as one of the seven primitive types (alongside number, string, bigint, undefined, symbol, and null). Primitives are stored and compared by value, not by reference, so true === true is always true no matter where each value came from.

What makes Booleans especially important is type coercion. Any place JavaScript expects a Boolean — the condition of an if, the test of a while loop, the operands of &&/||, the argument to Boolean() — it doesn’t require an actual Boolean value. Instead, the engine runs an internal algorithm called the ToBoolean abstract operation on whatever value is given, converting it into true or false. Every value in JavaScript is therefore either truthy (coerces to true) or falsy (coerces to false). Knowing the short, memorizable list of falsy values is one of the most practical things you can learn about the language.

Syntax

let flag = true;
let other = false;

Boolean(value);   // explicit conversion function
!!value;          // shorthand double-NOT conversion
typeof flag;      // "boolean"
  • true / false — the two literal keywords; always lowercase, never quoted (quoting them makes a string, not a Boolean).
  • Boolean(value) — a built-in function that explicitly converts any value to its Boolean equivalent using the ToBoolean rules.
  • !!value — a common idiom: the first ! converts and inverts the value to a Boolean, the second ! inverts it back, leaving a clean Boolean with the same truthiness as the original value.
  • typeof value — returns the string "boolean" when applied to a real Boolean primitive.

Examples

Example 1: Boolean literals and comparisons

let isLoggedIn = true;
let hasPermission = false;

console.log(isLoggedIn);
console.log(typeof isLoggedIn);
console.log(hasPermission);

const age = 20;
const isAdult = age >= 18;
console.log(isAdult);
Output:
true
boolean
false
true

Here isLoggedIn and hasPermission are Boolean literals assigned directly. isAdult, on the other hand, is never assigned true or false directly — it is the result of the comparison age >= 18. Every comparison operator in JavaScript always evaluates to a genuine Boolean.

Example 2: Truthy and falsy conversion with Boolean()

console.log(Boolean(0));
console.log(Boolean(1));
console.log(Boolean(""));
console.log(Boolean("hello"));
console.log(Boolean(null));
console.log(Boolean(undefined));
console.log(Boolean(NaN));
console.log(Boolean([]));
console.log(Boolean({}));

console.log(!!"programming");
console.log(!!0);
Output:
false
true
false
true
false
false
false
true
true
true
false

This example shows the ToBoolean algorithm in action. Notice that an empty array [] and an empty object {} are both truthy — a very common surprise for beginners coming from other languages. Only a small, fixed set of values are falsy; everything else, including every object and every non-empty string, is truthy.

Example 3: A realistic checkout eligibility check

function canCheckout(cart, isLoggedIn, hasPaymentMethod) {
  const cartHasItems = cart.length > 0;
  return isLoggedIn && cartHasItems && hasPaymentMethod;
}

const cart1 = ["book", "pen"];
console.log(canCheckout(cart1, true, true));
console.log(canCheckout(cart1, false, true));
console.log(canCheckout([], true, true));

const isEligible = 5 > 3 && "abc".length === 3;
console.log(isEligible);
Output:
true
false
false
true

This mirrors how Booleans are actually used in real applications: as the return value of small predicate functions that combine several conditions with logical operators. canCheckout returns a single Boolean that callers can use directly in an if statement, without needing to know the details of how it was computed.

Under the Hood: Truthy/Falsy Coercion and Short-Circuiting

Whenever the engine needs a Boolean but receives something else, it applies ToBoolean. The complete list of falsy values in JavaScript is short enough to memorize:

Value Falsy?
false Yes
0 and -0 Yes
0n (BigInt zero) Yes
"" (empty string) Yes
null Yes
undefined Yes
NaN Yes
Everything else (objects, arrays, functions, non-empty strings, any nonzero number) No — truthy

This matters most inside if/while conditions and the logical operators &&, ||, and !. These operators don’t actually return true/false themselves in every case — && and || return one of their original operands, chosen using truthiness, which is why patterns like const name = input || "Guest"; work as defaults. && evaluates its left operand; if it’s falsy, it short-circuits and returns that falsy value without even evaluating the right side; if it’s truthy, it evaluates and returns the right operand. || does the opposite: it returns the left operand if truthy, otherwise evaluates and returns the right one. This short-circuiting behavior is why && is often used to conditionally run code (isLoggedIn && showDashboard()) and why accessing a property on a possibly-missing object (user && user.name) avoids errors. Only the unary ! operator always produces a real, coerced Boolean.

Common Mistakes

Mistake 1: Using new Boolean()

Wrapping a primitive in the Boolean constructor with new creates a Boolean object, not a primitive — and objects are always truthy, even when they wrap false.

const flag = new Boolean(false);
if (flag) {
  console.log("This runs because flag is an object, always truthy");
}
console.log(typeof flag);
Output:
This runs because flag is an object, always truthy
object

The fix is simple: never use new Boolean(). Use the literal false, or call Boolean(value) without new, which correctly returns a primitive.

Mistake 2: Assuming any string looks “falsy”

Beginners often expect the string "false" to behave like the Boolean false. It doesn’t — it’s a non-empty string, and non-empty strings are always truthy regardless of their content.

const value = "false";
if (value) {
  console.log('Truthy, because non-empty strings are always truthy, even "false"');
}
console.log(Boolean(value));
Output:
Truthy, because non-empty strings are always truthy, even "false"
true

If you’re checking a value that came from user input, form data, or an API (which often arrives as text), convert it explicitly — for example compare value === "false" rather than relying on truthiness — instead of trusting automatic coercion.

Best Practices

  • Never write new Boolean(...); it creates a truthy object wrapper, which almost always causes bugs in conditionals.
  • Use strict equality (===/!==) when comparing values, and let comparison operators produce your Booleans naturally rather than hand-building them.
  • Memorize the seven falsy values (false, 0, -0, 0n, "", null, undefined, NaN) so truthy/falsy checks in if statements never surprise you.
  • Prefer Boolean(value) or !!value when you need to explicitly normalize a value to a real Boolean, especially before storing it or returning it from a function.
  • Use && and || intentionally for short-circuiting, but reach for the nullish coalescing operator ?? instead of || when you specifically want to fall back only on null/undefined, not on other falsy values like 0 or "".
  • Name Boolean variables so their meaning is obvious at a glance, using prefixes like is, has, can, or should (e.g. isVisible, hasError).

Practice Exercises

  • Exercise 1: Write a function isEven(n) that returns a Boolean indicating whether a number is even, using the modulo operator and a comparison (no if statement needed).
  • Exercise 2: Without running any code, list which of the following are truthy and which are falsy: " " (a single space), 0, "0", [], null, NaN, -1. Then verify your answers with Boolean().
  • Exercise 3: Write a function canVote(age, isCitizen) that returns true only if age is 18 or older and isCitizen is true, using a single return statement with logical operators.

Summary

  • Booleans are a primitive type with exactly two values: true and false.
  • Comparison operators (===, >, <=, etc.) always produce a real Boolean.
  • Every JavaScript value is either truthy or falsy; only seven specific values are falsy — everything else, including empty arrays and objects, is truthy.
  • The && and || operators return one of their operands (not necessarily a Boolean) and short-circuit evaluation based on truthiness.
  • Avoid new Boolean() — it produces an always-truthy object, not a usable Boolean primitive.
  • Use Boolean(value) or !!value to explicitly and safely convert any value to a true Boolean.