Boolean logic with AND, OR, and NOT

Understanding Boolean logic with AND, OR, and NOT

&& and || are usually called boolean operators, but neither one produces a boolean. Each evaluates its left operand, tests only that operand's truthiness, and then returns one of the two operands untouched: a && b gives back a when a is falsy and b otherwise, while a || b gives back a when a is truthy and b otherwise. That is why 0 || 3 is 3 and 1 && 2 is 2 — these operators choose a value, they do not compute a truth value. ! is the exception: it always coerces and always yields true or false, which is why !!x is the shortest way to force a real boolean.

The choice is made before the second operand is evaluated at all, and that short-circuiting is part of the semantics, not an optimisation detail. If the left operand of && is falsy the right side never runs, so a function call, assignment, or property access sitting there simply does not happen; || skips its right side when the left is truthy. This is what makes user && user.name safe on a null user, and it means the order of the operands is part of what the expression means rather than a matter of taste.

When operators mix, grouping comes from precedence: ! binds tightest, then &&, then ||, so a || b && c parses as a || (b && c) and never as (a || b) && c. Precedence decides parsing, not evaluation order — in true || (x && y) the group is parsed first and still never evaluated. For negations, apply De Morgan's laws instead of intuition: !(a && b) is !a || !b, and !(a || b) is !a && !b, flipping each operand and swapping the operator. Forgetting the swap is how a test meant to catch "either one is missing" quietly becomes "both are missing".

const title = "";
const fallback = "untitled";

// && returns the first falsy operand, otherwise the last one
console.log(JSON.stringify(title && title.toUpperCase()));

// || returns the first truthy operand, otherwise the last one
console.log(JSON.stringify(title || fallback));

// ! is the only one of the three that always produces a boolean
console.log(!title, typeof (title || fallback));

function probe(tag) {
  console.log("probe ran for " + tag);
  return true;
}

const skipped = false && probe("A");
const evaluated = true && probe("B");
console.log(skipped, evaluated);

Worked examples

const cached = true;
const online = false;
const stale = true;

console.log(cached || online && !stale);
console.log(cached || (online && !stale));
console.log((cached || online) && !stale);

const rows = [[true, true], [true, false], [false, true], [false, false]];

console.log("a      b      !(a&&b)  !a||!b  !a&&!b");
for (const [a, b] of rows) {
  console.log(
    String(a).padEnd(7) +
    String(b).padEnd(7) +
    String(!(a && b)).padEnd(9) +
    String(!a || !b).padEnd(8) +
    String(!a && !b)
  );
}

const config = { retries: 0, host: " api.dev " };

console.log(1 || 2, 1 && 2, "" || "fallback");
console.log(config.retries || 3);
console.log(!!config.retries, !!config.host);
console.log(config.host && config.host.trim());
console.log(typeof (config.retries || 3), typeof !!config.retries);

Important notes

Common mistakes

Try it yourself