Booleans & truthiness

true and false

A boolean is JavaScript's smallest yes/no answer. There are only two primitive boolean values: true and false. You will see them in variables with names like isOpen, hasItems, isLoggedIn, and checked.

1const isOpen = true;2const hasItems = false;3console.log(typeof true);4console.log(isOpen);5console.log(hasItems);

Line 3 prints "boolean" because true is a primitive boolean, not a string. Lines 4 and 5 print the values stored in yes/no variables. The variable names are not required, but names that start with is, has, or can make boolean code easy to read.

This lesson stays focused on booleans. The engine-side story is in Booleans inside the engine. The later Booleans, null & undefined lesson compares booleans with the two common missing-value markers side by side.

Beginners often write true and false directly first. Soon after, booleans start coming from questions: comparisons, methods that ask yes/no questions, and the not operator !.

1const isOpen = true;Run2const hasItems = false;3const trueType = typeof true;4const bigger = 5 > 3;5const sameLetter = "a" === "A";6const hasEll = "hello".includes("ell");7const isArray = Array.isArray([]);8const isReallyNaN = Number.isNaN(NaN);9const startsWithC = "cat".startsWith("c");10const isClosed = !isOpen;11console.log(isOpen, hasItems, trueType);12console.log(bigger, sameLetter);13console.log(hasEll, isArray, isReallyNaN, startsWithC);14console.log(isClosed);

Read the names out loud. bigger asks whether 5 > 3. hasEll asks whether the string contains a piece of text. isArray asks whether a value is an array. isClosed flips isOpen with !.

Sometimes you already have a value and you want to know how JavaScript will treat it in a condition. Use Boolean(value) for the explicit answer. You will also see !!value, which uses two not operators to end up with the same primitive boolean.

1const value = "";Run2const explicit = Boolean(value);3const compact = !!value;4const flipped = !value;5if (value) {6  console.log("truthy branch");7} else {8  console.log("falsy branch");9}10console.log(explicit, compact, flipped);

if (value) uses the same conversion to choose a branch. It does not change the original value. One ! flips the answer; two !! flips it back to the truthiness answer.

The eight falsy values

The everyday falsy list is short and exact. Memorize these eight values; every other ordinary JavaScript value is truthy.

• false
• 0
• -0
• 0n
• ""
• null
• undefined
• NaN

The surprises are all on the truthy side: "0", "false", " ", [], , functions, symbols, and wrapper objects all pass a truthiness check.

Try many values and expressions. The playground shows Boolean(value), !!value, and the branch chosen by if (value). The computed-expression group includes classic bugs such as "abc".indexOf("a") returning 0 and floating-point math leaving a tiny truthy number.

1const value = "0";2console.log(Boolean(value));3console.log(!!value);4if (value) {5  console.log("truthy branch");6} else {7  console.log("falsy branch");8}

Here is every value from the playground at once, grouped the same way: empty values, strings, numbers, BigInts, objects, wrapper objects, and computed expressions. The middle column is computed from the real value when the page is built, not typed by hand.

Booleans in conditions and logic

Conditions use truthiness. The ! operator returns a primitive boolean. The logical operators && and || are a little different: they choose and return one of their original operands. The full lesson is Logical operators; here is the beginner preview.

1const name = "";2const fallback = name || "friend";3const subscribed = true;4const access = subscribed && "member area";5console.log(fallback);6console.log(access);7console.log(!subscribed);

Line 2 returns the fallback string because name is the empty string. Line 4 returns the string "member area", not the boolean true. Line 7 uses !, so it prints a real boolean.

Boolean(x) without new returns a primitive boolean. new Boolean(false) creates an object wrapper. Objects are truthy, so the wrapper is dangerous in conditions.

1const boxed = new Boolean(false);2console.log(Boolean(boxed));3console.log(typeof boxed);4console.log(boxed.valueOf());5console.log(Boolean(false));

A second trap is comparing values with == true or == false. When loose equality sees a boolean, it converts toward numbers. That creates surprising results.

1console.log("1" == true);2console.log("true" == true);3console.log([] == false);4console.log(Boolean([]));

Prefer if (value) when you mean “truthy,” or value === true when you require the primitive boolean true exactly.

Practical booleans

Booleans show up in interface state, form controls, array checks, filters, and URL parsing. The pattern depends on what question you are asking.

• Toggles: flip a boolean with isOpen = !isOpen.
• Form controls: a checkbox exposes a boolean .checked property.
• Arrays: use if (items.length) to ask whether the list has items.
• Cleanup: array.filter(Boolean) removes falsy values, including 0.
• Strings from URLs or forms: parse "true" and "false" with exact comparisons.

1let isOpen = false;2isOpen = !isOpen;3console.log(isOpen);4const checkbox = { checked: true };5console.log(checkbox.checked);

1const items = ["hat", "coat"];2if (items.length) {3  console.log("show cart");4}5const mixed = [0, 1, "", "Ada", null, false, true];6console.log(mixed.filter(Boolean).join("|"));

1const fromUrl = "false";2console.log(Boolean(fromUrl));3console.log(fromUrl === "true");4console.log(fromUrl === "false" ? false : fromUrl === "true");

Common misconceptions

• “The string "false" is false.” It is a non-empty string, so it is truthy.
• “Whitespace is empty.” " " and "\n" contain characters and are truthy.
• “Empty arrays and objects are falsy.” They are objects, and ordinary objects are truthy.
• “new Boolean(false) behaves like false.” It is an object, so it is truthy.
• “== true checks truthiness.” It follows loose-equality conversions instead.
• “filter(Boolean) only removes missing values.” It removes every falsy value, including 0.
• “if (value) is a missing-value check.” It also rejects false, 0, "", and NaN.

Key takeaways

• Primitive booleans are exactly true and false.
• Comparisons, yes/no methods, and ! produce primitive booleans.
• The everyday falsy list is false, 0, -0, 0n, "", null, undefined, and NaN.
• Everything else ordinary is truthy, including "false", [], , and new Boolean(false).
• Avoid == true; use if (value) for truthiness or value === true for the exact primitive.
• Use practical checks carefully: items.length, filter(Boolean), and raw === "true" each answer different questions.

Final definition: a boolean is the primitive yes/no value true or false; truthiness is JavaScript's automatic boolean reading of any value.

Up next: undefined, the value JavaScript uses when something has not been supplied yet.