In JavaScript, how do the logical assignment operators `&&=`, `||=` and `??=` differ from writing `x = x && y`, and why does that difference matter for a property with a setter?

## The three operators ES2021 added three compound assignment operators that combine a logical test with an assignment: ```js x ||= y; // assign y if x is falsy x &&= y; // assign y if x is truthy x ??= y; // assign y if x is null or undefined ``` Each mirrors the test of the corresponding binary operator: `||` on falsiness, `&&` on truthiness, `??` on nullishness. ## They short-circuit the WRITE, not just the value The usual explanation — "`x ||= y` is short for `x = x || y`" — is wrong in a way interviewers like to probe. The specification evaluates the left-hand reference, reads its value, applies the test, and *returns early without performing a Set* when the test says the current value stands. Only when the test passes is the right operand evaluated and the assignment performed. With `x = x || y` there is always a write, even if the value written is identical to the one already there. That distinction is invisible for a plain variable and very visible for anything where writing has behaviour attached. ### A setter ```js const target = { _v: 0, get v() { return this._v; }, set v(next) { console.log('set called'); this._v = next; } }; target.v ||= 5; // logs 'set called' — 0 is falsy, so it writes target.v ??= 9; // logs nothing — 5 is not nullish, no write happens console.log(target.v); // 5 ``` ### A Proxy A `Proxy` with a `set` trap sees the same thing: the `get` trap runs to read the current value, but the `set` trap is only invoked when the assignment actually happens. Anything built on write interception — change tracking, dirty flags, persistence, reactivity — therefore behaves differently between `obj.a ||= v` and `obj.a = obj.a || v`. ### A frozen or non-writable property In strict mode (which includes all module code and class bodies), assigning to a non-writable property throws a `TypeError`. Logical assignment skips that when it short-circuits: ```js 'use strict'; const o = Object.freeze({ a: 1 }); o.a ||= 2; // no error: 1 is truthy, so no write is attempted o.a = o.a || 2; // TypeError: Cannot assign to read only property 'a' ``` ## The right operand is lazy too As with the binary operators, the right-hand expression is only evaluated when it is needed: ```js cache.value ??= buildExpensiveThing(); // builder runs at most once ``` That makes `??=` a compact memoisation idiom, provided the computed value is never itself `null` or `undefined` — if it can be, the guard will re-run every call and you need an explicit sentinel or a `has`-style check instead. ## Choosing among the three - `??=` fills in defaults for options and config: `opts.retries ??= 3` preserves a deliberate `0`. - `||=` fills in defaults where any falsy value counts as missing, e.g. replacing an empty label. - `&&=` is the rarest: it updates a value only if there is already one there, such as `user.token &&= refresh(user.token)` — refresh only what exists. ## Evaluation of the target happens once The reference on the left is evaluated a single time, which matters when it has side effects or is expensive: ```js arr[index()] ??= compute(); // index() is called once arr[index()] = arr[index()] ?? compute(); // index() called twice ``` This is the same benefit compound operators like `+=` have always had, and it is a correctness issue, not just a performance one, when the subscript expression is impure. ## Interaction with the mixing restriction Just as `??` cannot be mixed with `||` or `&&` in one unparenthesised expression, there is no operator that combines two of these tests. If a default must apply to both `null` and the empty string, write the condition out explicitly rather than stacking operators. ## What to say in an interview Give the three tests, then immediately make the point that stands out: the assignment itself short-circuits, so no `Set` occurs when the value is kept. Back it with the setter or frozen-object example — that is the observable proof the desugaring "`x = x || y`" is not exact.