Parameters, Defaults and Rest

## What a default parameter is Since ES2015 a function parameter can carry an initialiser directly in the signature: ```js function greet(name = 'guest') { return `hello ${name}`; } ``` The expression after `=` is the *default value*. It is not applied unconditionally: the runtime binds each parameter to the corresponding argument, and then, for each parameter that has an initialiser, checks whether the bound value is `undefined`. Only in that case is the initialiser evaluated and its result assigned. ## The single trigger: undefined The rule has no exceptions worth remembering beyond the one word: **undefined**. Two situations produce it. 1. The argument is missing. `greet()` passes no argument, so `name` starts out `undefined`. 2. The argument is present but its value is `undefined`. `greet(undefined)` is indistinguishable from `greet()` as far as the default is concerned. Everything else is a real value and is kept: ```js greet(); // 'hello guest' greet(undefined); // 'hello guest' greet(null); // 'hello null' greet(0); // 'hello 0' greet(''); // 'hello ' greet(false); // 'hello false' greet(NaN); // 'hello NaN' ``` That `greet(null)` line is where candidates most often guess wrong. `null` is a deliberate "no value" *value*; the language treats it as data the caller chose to send, not as an absence. ## Why this differs from the `||` idiom Before defaults existed, the common pattern was: ```js function area(width) { width = width || 100; // pre-ES2015 idiom return width * width; } area(0); // 10000 — the zero was thrown away ``` `||` tests *falsiness*, so it swallows `0`, `''`, `false`, `NaN` and `null` along with `undefined`. That is a real bug class: a user-supplied `0` silently becomes the fallback. Parameter defaults test only `undefined`, which is almost always the behaviour you meant. The nullish coalescing operator `??` (ES2020) sits between the two — it falls back for `undefined` *and* `null`, but not for other falsy values: ```js function area(width) { const w = width ?? 100; // 0 survives, null does not return w * w; } ``` So if your API wants `null` to mean "use the default", combine the two: keep the parameter default for the omitted case and normalise `null` in the body, or drop the parameter default and use `??` alone. ## Interaction with positional arguments Because a default only fires on `undefined`, `undefined` becomes the idiomatic "skip this one" placeholder when you want a later positional argument: ```js function slice(source, start = 0, end = source.length) { return source.slice(start, end); } slice('abcdef', undefined, 3); // 'abc' — start falls back to 0 ``` Passing `null` there would give `start === null`, which coerces to `0` in the arithmetic but is a different value entirely and would break a parameter whose default is a non-numeric object. This awkwardness is the usual argument for switching to a destructured options object once a function has more than two or three optional inputs. ## A default is an expression, evaluated per call The initialiser is a full expression, not a literal, and it is re-evaluated on every call that needs it. `function log(msg, at = Date.now()) {}` stamps a fresh timestamp each time, and `function collect(item, into = [])` creates a brand-new array per call, so calls never share state through the default. The expression can also call a function, which gives the standard "required argument" trick: ```js const required = (name) => { throw new TypeError(`${name} is required`); }; function save(record = required('record')) { return record; } save(); // TypeError: record is required save(null); // returns null — null is a value, so nothing throws ``` That last line is the same lesson again: the guard only fires on `undefined`. ## What an interviewer is checking They want to hear the word `undefined` used precisely, the explicit statement that `null` and `0` are preserved, and ideally the contrast with `||` and `??`. Saying "the default kicks in when the argument is missing" is only half right — it misses `f(undefined)`, which is the case that actually shows up in real code when one function forwards an unset variable to another.