In JavaScript, what exactly does the optional chaining operator `?.` short-circuit, and in which situations does an expression containing `?.` still throw?

## What the operator does `?.` is a property-access operator with a guard. `obj?.prop` evaluates `obj`; if the result is `null` or `undefined`, the expression evaluates to `undefined`; otherwise it performs the normal property access. Three forms exist: ```js obj?.prop // optional property access obj?.[expr] // optional computed access fn?.(args) // optional call ``` The last one is why the bracket and paren forms keep the dot: `obj?.[k]` and `fn?.()`, not `obj?[k]`. ## Short-circuiting is chain-wide, not link-wide The most important behaviour is that a nullish check does not just skip one access — it aborts the whole *optional chain*. Everything to the right, in the same chain, is left unevaluated: ```js const a = null; a?.b.c.d; // undefined, no error a?.b().c[expensive()]; // undefined; expensive() is never called ``` That includes call arguments. This is observable when arguments have side effects: ```js let calls = 0; const arg = () => { calls++; return 1; }; const obj = null; obj?.method(arg()); console.log(calls); // 0 ``` ## What it does NOT protect `?.` guards only the value immediately to its left. A plain `.` further down the chain is still a plain `.`: ```js const o = { a: {} }; o?.a.b.c; // TypeError: Cannot read properties of undefined (reading 'c') ``` Here `o` is not nullish, `o.a` is `{}`, `o.a.b` is `undefined`, and the unguarded `.c` throws. Guarding every uncertain link means `o?.a?.b?.c`. Writing `?.` once at the front and assuming the rest is safe is the single most common misunderstanding of the operator. ## Parentheses end the chain Short-circuiting propagates through the syntactic chain, and a parenthesised sub-expression is a new one: ```js const a = null; a?.b.c; // undefined (a?.b).c; // TypeError — a?.b is undefined, then .c is a fresh access ``` ## Optional calls tolerate nullish, not non-callable `fn?.()` means "call `fn` if it exists". If `fn` is `null` or `undefined` the result is `undefined`. If `fn` holds any other non-callable value, you get a normal `TypeError`: ```js let fn; fn?.(); // undefined fn = 'hi'; fn?.(); // TypeError: fn is not a function ``` The idiomatic use is optional callbacks: `options.onDone?.()` replaces `if (options.onDone) options.onDone()` and, importantly, calls the method with the right receiver when written as `obj.handler?.()`. ## Undeclared variables still throw `?.` is not a general "don't throw" operator. If the base identifier was never declared, the reference itself fails before any nullish check happens: ```js notDeclared?.x; // ReferenceError: notDeclared is not defined ``` For genuinely optional globals, `typeof notDeclared !== 'undefined'` is still the tool; `globalThis.notDeclared?.x` also works because the property access on `globalThis` yields `undefined` rather than throwing. ## Where it may and may not appear Optional chaining is a read operator. It cannot be the target of an assignment — `a?.b = 1` is a SyntaxError — and it cannot be used in a `new` expression (`new a?.()` is a SyntaxError). It *is* allowed with `delete`, where a nullish base makes the operation a no-op that returns `true`: ```js const a = null; delete a?.b; // true, nothing happened ``` ## Pairing with ?? Because a short-circuited chain produces `undefined`, `?.` composes naturally with the nullish coalescing operator: `user?.prefs?.theme ?? 'dark'` reads as "drill in if possible, otherwise default". This is the pattern most production code actually uses. ## Judgment: don't paper over structure Sprinkling `?.` on every access hides real defects. If a value is supposed to exist by the time this code runs, a thrown `TypeError` at the point of corruption is far more useful than an `undefined` that silently flows three layers downstream and fails somewhere unrelated. Use `?.` where absence is a genuine, expected state — optional config, optional callbacks, results that may not have loaded — and let genuinely broken invariants throw.