In JavaScript, what value do the `||` and `&&` operators produce — a boolean, or one of their operands? Walk through `'' || 'default'` and `0 && compute()`.

## They are not boolean operators The name "logical operators" is misleading. In many languages `||` and `&&` take booleans and produce booleans. In JavaScript they take *any two values* and produce **one of those two values**, unchanged. The boolean only appears internally, as the test. The evaluation rule for `a || b`: 1. Evaluate `a`. 2. Apply ToBoolean to the result. 3. If it is `true`, return `a`'s value — `b` is never evaluated. 4. Otherwise evaluate `b` and return its value, whatever it is. `a && b` is the exact mirror: 1. Evaluate `a`. 2. Apply ToBoolean to the result. 3. If it is `false`, return `a`'s value — `b` is never evaluated. 4. Otherwise evaluate `b` and return its value. A useful one-liner: `||` returns the **first truthy operand, or the last operand**; `&&` returns the **first falsy operand, or the last operand**. Chains follow directly — `a || b || c` yields the first truthy of the three, falling back to `c`. ```js '' || 'default'; // 'default' — '' is falsy, so the right operand is returned 'a' || 'b'; // 'a' — not true 0 && compute(); // 0 — compute() is never called 'a' && 42; // 42 null && anything; // null — the falsy operand itself comes back ``` Notice that `0 && compute()` returns the number `0`, not `false`. The falsy operand is handed back **verbatim**, preserving its type. This is the detail interviewers are actually probing. ## Short-circuiting is a control-flow feature Because the unselected operand is never evaluated, `&&` and `||` are the only operators besides `?:` and `??` that can skip work. This underpins three everyday idioms: ```js // guarded call — load() runs only if obj is truthy obj && obj.load(); // cheap-first ordering — the expensive check runs only when needed if (cache.has(key) || expensiveLookup(key)) { /* … */ } // fallback value const name = input || 'anonymous'; ``` It also means an operand with side effects is conditional, which cuts both ways: `count++ && log()` increments always, while `flag && count++` increments only sometimes. When reviewing, treat any function call on the right of `&&`/`||` as "may not happen". ## Returning an operand, not a boolean, has consequences Because the result carries its original type, a value can leak somewhere you expected a boolean: ```js function hasItems(list) { return list && list.length; // returns undefined, 0, or a number — not a boolean } ``` The caller writing `if (hasItems(x))` still works, because they re-apply ToBoolean — but the function's contract is a lie, `hasItems(x) === true` fails, and serialising the result puts a number in your JSON. If a boolean is the contract, produce one: `return Boolean(list && list.length)` or `return !!list?.length`. The contrast with `!` is worth stating explicitly: `!` always yields a genuine boolean, so `!!x` is the canonical coercion. `x || y` is not a coercion at all. ## Precedence and grouping `&&` binds tighter than `||`, so `a || b && c` parses as `a || (b && c)`. Both bind looser than comparison operators, which is why `a === 1 || a === 2` works without parentheses. Mixing either operator with `??` in the same expression without parentheses is a **SyntaxError** — the language forces you to be explicit rather than guess a precedence. ## Assignment forms `||=` and `&&=` apply the same test and, importantly, **short-circuit the assignment itself**: `a ||= b` assigns only when `a` is falsy, so a setter or a proxy trap does not fire on the skipped path. That is a different behaviour from `a = a || b`, which always writes. ## What a strong answer sounds like Say the mechanism, not the folklore: the operator tests the left operand with ToBoolean and returns one of the operands unchanged, so the result's type is whatever was selected; the other operand is not evaluated; and if you need a real boolean you wrap the expression in `Boolean(...)` or `!!`. Then give one concrete pair — `0 || 'x'` is `'x'`, `0 && f()` is `0` and `f` never runs — because that pair demonstrates both halves at once.