In JavaScript, why is `function connect({ retries = 3, timeout = 1000 } = {})` written with the trailing `= {}`, and what call still breaks it?

## Why signatures grow options objects Once a function has three or more optional inputs, positional parameters become painful: callers must pass `undefined` as a placeholder to reach a later one, and every call site is an unreadable row of literals. The standard answer is a single destructured parameter object: ```js function connect({ retries = 3, timeout = 1000, secure = true } = {}) { return { retries, timeout, secure }; } connect(); // all defaults connect({ timeout: 250 }); // one override, order-free, self-documenting ``` The pattern replaces positional order with names, so callers can supply any subset in any order, and adding a new option later does not disturb existing calls. ## The two layers of defaults There are two independent default mechanisms in that signature, and conflating them is the usual mistake. **Inner defaults** — `retries = 3` inside the braces — apply per property, when that property is missing from the object or present with the value `undefined`. They do nothing about the object itself. **The outer default** — `= {}` after the closing brace — is an ordinary parameter default on the whole parameter. It applies only when the argument is `undefined`. Drop the outer one and the no-argument call fails: ```js function connect({ retries = 3 }) { return retries; } connect({}); // 3 — fine connect(); // TypeError: Cannot destructure property 'retries' of 'undefined' as it is undefined. ``` Destructuring works by reading properties off the value, and reading a property of `undefined` is a `TypeError`. The `= {}` supplies a throwaway object for exactly that case, and the inner defaults then fill it in. ## The call that still breaks `= {}` fires only for `undefined`. `null` is a distinct value: ```js connect(null); // TypeError: Cannot destructure property 'retries' of 'null' as it is null. ``` This matters in real systems because `null` is what arrives from JSON payloads, from database columns, and from code that initialises a variable to `null` for "nothing yet" and then forwards it. A signature that looks fully defensive is still one `null` away from a crash. The body-level form is what covers both: ```js function connect(options) { const { retries = 3, timeout = 1000 } = options ?? {}; return { retries, timeout }; } connect(); // ok connect(null); // ok — ?? treats null as absent too ``` You trade the self-documenting signature for robustness. A common middle ground is to keep the destructured signature for internal functions, where you control every caller, and normalise explicitly at the boundaries where untrusted or serialised data arrives. ## Other behaviours worth knowing **Explicit undefined properties take the default.** `connect({ timeout: undefined })` yields `timeout === 1000`, because the property default has the same `undefined`-only trigger. `connect({ timeout: null })` yields `null` — the default is skipped and a null reaches your code. **Renaming plus defaulting** combine as `{ timeout: ms = 1000 }`, which binds a local `ms`. The name before the colon is the property; the name after it is the local binding. **Nesting compounds the problem.** `function f({ retry: { limit = 3 } = {} } = {})` needs a default at every level, because each nested pattern independently destructures whatever it finds. Deep option objects are usually a sign the API should be flattened. **Rest inside the pattern collects the leftovers:** `function f({ id, ...rest } = {})` gives `rest` as an object of the remaining own enumerable properties — useful for forwarding unknown options onward, and equally useful for silently swallowing typos, since a misspelled option lands in `rest` instead of raising an error. If typo safety matters, validate the received keys rather than relying on the shape of the signature. **Arity is affected.** A destructured parameter counts as one parameter, and one with a default counts as zero, so `connect.length` is `0` for the signature above. Anything that inspects declared arity sees nothing about the options. ## What an interviewer is listening for The crisp version: destructuring `undefined` throws, so `= {}` makes the argument optional; `null` is not `undefined`, so it still throws; inner defaults handle missing properties, the outer default handles a missing object. The senior addition is knowing where `null` actually comes from in production and choosing the body-level `?? {}` normalisation at those boundaries.