Booleans and Logic

A boolean is a value that is either true or false. There are only two of them. They are the smallest, simplest, and possibly the most important type in the language — because every decision a program ever makes is, at the bottom, a boolean.

Where booleans come from

You rarely write the literals true and false directly. Booleans usually come from comparisons and logical expressions.

Comparison operators

(The loose == and != exist too; we will keep avoiding them.)

A surprising one: strings can be compared with <, >, etc. They compare lexicographically (dictionary order, but using the Unicode code point of each character). This matters because uppercase letters have lower Unicode values than lowercase ones, so "Z" < "a" is true. When comparing user-facing text, use locale-aware methods like "a".localeCompare("B").

The three logical operators

Once you have boolean values, you combine them with three logical operators:

Truth tables

The classic way to learn the operators is a tiny table:

a && b

a || b

| a | b | a || b | | :---: | :---: | :---: | | false | false | false | | false | true | true | | true | false | true | | true | true | true |

!a

Short-circuit evaluation

This is one of the most useful properties of && and ||:

• a && b only evaluates b if a is truthy. If a is falsy, the result is a and b is never touched.
• a || b only evaluates b if a is falsy. If a is truthy, the result is a and b is never touched.

This is called short-circuit evaluation. The right-hand side might never run.

Two practical patterns use short-circuiting all the time:

• Default values: const greeting = name || "stranger"; → if name is empty/falsy, use "stranger".
• Safe conditional action: user && user.notify(); → only call notify() if user is truthy.

In modern code, the special nullish coalescing operator ?? is often a better choice than || for defaults, because it only triggers on null/undefined (not 0 or ""):

Pick ?? when you specifically mean "fall back if missing", and || when you mean "fall back if falsy (empty, zero, false, …)".

Truthy and falsy, revisited

Recall from Values and Types — every value can be used in a boolean context. The falsy values are:

• false
• 0 (and -0, 0n)
• ""
• null
• undefined
• NaN

Everything else is truthy. That fact unlocks short, readable idioms:

The if (name) check covers all "missing or empty" cases at once. This is concise and idiomatic — just remember it also rules out 0 and false, which sometimes matters.

De Morgan's laws (very useful!)

Two algebraic identities that come up constantly in real code:

• !(a && b) is equivalent to !a || !b
• !(a || b) is equivalent to !a && !b

In plain English: "not both" is "not one, or not the other", and "neither" is "not one, and not the other".

These are not just pedantic. They let you simplify confusing negations into cleaner conditions.

The ternary expression: a ? b : c

This is not strictly a logic operator, but it lives in the same neighbourhood. The ternary operator lets you choose between two values based on a condition:

const result = condition ? valueIfTrue : valueIfFalse;

Use it for small, single-line choices. For anything more complicated, use a regular if/else — readability beats cleverness.

A worked example: a tiny rule engine

Below is a small example that combines comparisons, logical operators, truthy/falsy, and the ternary. It models a "can this user post a comment?" rule. Read each canComment line carefully — it expresses a fairly complex business rule in a single, readable line.

That single boolean expression in canComment encodes a rule that might take a paragraph of English to describe. This is why booleans are the most powerful tiny thing in programming.

Challenge