Booleans, null & undefined

The yes/no family

JavaScript often needs a plain yes or no. Is the menu open? Did the user finish the form? Should this message be visible? The two boolean values answer those questions: true means yes, and false means no.

1const subscribed = true;2const muted = false;3console.log(subscribed);4console.log(muted);

This lesson puts two neighbors beside them: null and undefined. They are not booleans, but they often stand near boolean decisions because JavaScript must also ask, “Do I have a value at all?” Each value has its own lesson (Booleans & truthiness, undefined, and null); here you compare them side by side and choose the right check.

We will use tiny if statements in this lesson because they are the easiest way to see truthiness. Control flow gets a full lesson later; for now, read if (value) as “if this value gets treated like true.”

JavaScript does not require a condition to be literally true or false. Before an if chooses a branch, JavaScript converts the value to a boolean. The complete falsy list is short enough to memorize:

• false
• 0 and -0
• 0n, BigInt zero
• "", the empty string
• null
• undefined
• NaN

Everything else is truthy. That includes "0", "false", " ", [], , -1, and Infinity. This is why truthiness is useful for “is there something here?” but dangerous when zero or an empty string is a valid answer.

Pick a value and watch three common checks agree: Boolean(value), !!value, and the branch chosen by if (value). The double exclamation mark is a common shorthand for “turn this into a real boolean.”

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

Notice the pattern: values that are empty containers are not necessarily falsy. An empty array is still an array object. An empty object is still an object. To ask whether a list has items, check its length; do not trust the array object itself.

null and undefined both mean “no useful value here,” but they tell different stories. null is a form field you cleared on purpose. undefined is a field nobody has filled in yet.

You saw typeof null in the Data types lesson: it returns "object". Treat that as an old quirk, not as a sign that null works like a normal object.

undefined appears in several ordinary places: an uninitialized let, a missing object property, a function with no return, a missing argument, or an array index that is out of range. null appears when code sets it deliberately, and some browser APIs return it when they find nothing. For example, document.querySelector(".missing") returns null in most browsers when no element matches. In the Talking to the user lesson, prompt can also return null when the user cancels.

1let notFilled;Run2const profile = { name: "Ada" };3function noReturn() {4  const message = "done";5}6function echo(nickname) {7  return nickname;8}9const list = ["first"];10const deliberatelyEmpty = null;11 12console.log(notFilled);13console.log(profile.age);14console.log(noReturn());15console.log(echo());16console.log(list[3]);17console.log(deliberatelyEmpty);

The hardest beginner bug is confusing “missing” with “falsy.” If a quantity can be 0, or a name can be an empty string, if (value) is too broad. Compare four checks side by side.

1const name = undefined;Run2console.log(Boolean(name));3console.log(name === undefined);4console.log(name == null);5console.log(name ?? "friend");

Two patterns are especially useful. Use value == null when you intentionally want to catch both null and undefined and nothing else. Use value ?? fallback, the nullish coalescing operator, when only null or undefined should fall back. The Operators module will spend a full lesson on comparisons, logical operators, nullish coalescing, and optional chaining.

Where you’ll use this

Boolean and missing-value checks appear in real interfaces constantly: optional form fields, shopping-cart quantities, feature toggles, search filters, and API responses. The key question is always: “Am I testing yes/no, or am I testing whether a value is missing?”

1function labelQuantity(quantity) {2  if (quantity == null) {3    return "missing";4  }5  return quantity + " selected";6}7console.log(labelQuantity(0));

This code accepts 0 as a real quantity. It only reports missing when the caller passes null or undefined.

Common misconceptions

• “Empty arrays are falsy.” They are truthy. Check array.length instead.
• “The string "false" is false.” It is a non-empty string, so it is truthy.
• “null and undefined are identical.” They are loosely equal but strictly different.
• “typeof null proves null is an object.” It is a historical result; do not use properties on null.
• “if (value) is a safe missing-value check.” It also rejects 0, "", false, and NaN.

1const cartItems = [];2 3if (cartItems) {4  console.log("cart exists");5}6 7if (cartItems.length === 0) {8  console.log("cart is empty");9}

Key takeaways

• Booleans are exactly true and false.
• Falsy values are exactly false, 0, -0, 0n, "", null, undefined, and NaN.
• Every object is truthy, including [] and .
• Use null for intentional emptiness and expect undefined when a value was not supplied.
• Use == null or ?? when you mean missing, not merely falsy.

Final definition: Truthiness is JavaScript’s automatic yes/no reading of any value; null and undefined are the two common ways it says “no value.”

Up next: BigInt.