?? vs || in JavaScript

The double-bar operator falls back when the left side is falsy, and falsy covers six values: false, zero, the empty string, null, a missing value and not-a-number. The nullish coalescing operator falls back only for null and a missing value, and nothing else.

That difference is the whole point, and it matters because zero, the empty string and false are legitimate values in most domains. A price of zero is not the same as a price you do not know. A count of zero is not the same as a count you have not loaded yet. An empty search string is a real answer, not an absent one.

So the rule is to use the nullish operator whenever the value is a number, a string or a boolean that could legitimately be empty, and to use the double-bar only when every falsy value should be treated as absent. In practice, the nullish operator is the safer default for defaults and fallbacks, because it never destroys real data.

There is one more difference to know. The nullish operator cannot be mixed with the double-bar or the double-ampersand in the same expression without parentheses, because the precedence would be ambiguous. That restriction was added deliberately to stop people writing a mixed expression and getting a result they did not expect.

The difference only shows up for values that are falsy but not null and not missing. Those are zero, the empty string, false and not-a-number.

const zero = 0;
const empty = "";
const no = false;

console.log(zero ?? 99);    // 0 - zero is a real value
console.log(zero || 99);    // 99 - zero is falsy

console.log(empty ?? "fallback");   // ""
console.log(empty || "fallback");   // "fallback"

console.log(no ?? false);   // false
console.log(no || true);    // true

const missing = null;
console.log(missing ?? "default");   // "default"
console.log(missing || "default");   // "default"

// The assignment versions behave the same way.
let value = 0;
value ||= 5;
console.log(value);   // 5

let other = 0;
other ??= 7;
console.log(other);   // 0 - zero is kept

The logical assignment operators follow the same rule. The double-bar assignment replaces the value when the current one is falsy, so a zero becomes five. The nullish assignment replaces it only when the current value is null or missing, so a zero stays zero.

These operators were added in the 2021 edition of the language. Before them, the equivalent code was a short-circuit assignment with a double bar, which had the same semantics as the new operator, or an explicit check for null or missing, which was more verbose.

The practical rule to give an interviewer is that you should almost always reach for the nullish variant when the value is a number, a string or a boolean, and reserve the double-bar for cases where you genuinely want every falsy value replaced. If you find yourself unsure, the nullish operator is the one that does less damage when you are wrong.