In JavaScript, when are default parameter expressions evaluated, and can one default refer to another parameter?

## Defaults are expressions, not constants Whatever follows `=` in a parameter list is an arbitrary expression: a literal, a function call, a template string, another parameter. The engine does not evaluate it when the function is defined. It evaluates it during *each call*, and only for the parameters whose bound value is `undefined`. ```js function log(message, at = Date.now()) { return `${at}: ${message}`; } ``` Every call that omits `at` gets a new timestamp. If defaults were captured at definition time, every log line would carry the module's load time instead. ## Lazy: skipped when an argument is supplied Evaluation is lazy in the ordinary sense — the initialiser does not run at all when the caller passes a value. ```js let calls = 0; const expensive = () => { calls += 1; return 42; }; function f(x = expensive()) { return x; } f(1); // calls === 0 f(); // calls === 1 ``` This is what makes the "required argument" idiom safe: a default that throws only throws on the calls that omit the argument. ## Fresh values per call Because the expression re-runs, mutable defaults are not shared across calls: ```js function collect(item, into = []) { into.push(item); return into; } collect(1); // [1] collect(2); // [2] — a different array ``` Each invocation that omits `into` allocates its own array. Sharing only happens if the caller passes the same array twice, which is then the caller's explicit choice. ## Left to right, and the temporal dead zone Parameters are initialised in the order they are written. Each one's binding exists but is *uninitialised* until its turn, exactly like a `let` declaration before its line. So a default may read anything already initialised to its left: ```js function cut(text, start = 0, end = text.length) { return text.slice(start, end); } cut('abcdef', 2); // 'cdef' — end saw text ``` and throws if it reads to its right: ```js function f(a = b, b = 2) { return [a, b]; } f(); // ReferenceError: Cannot access 'b' before initialization f(1); // [1, 2] — a is supplied, so its initialiser never runs ``` Note the second line: the error is a *runtime* error on the calls that actually evaluate the bad initialiser, not a syntax error at parse time. A function with this defect can sit in a codebase looking fine until someone omits the first argument. ## The parameter scope is separate from the body scope When any parameter has an initialiser, the parameter list gets its own scope, and the body's declarations sit in a child scope. A default therefore cannot see a `let`, `const` or `var` declared in the body — it resolves the outer binding instead: ```js let mode = 'outer'; function f(m = mode) { let mode = 'inner'; return m; } f(); // 'outer' ``` The converse is that a default can close over a parameter and produce a function that keeps seeing it: ```js function make(a, getA = () => a) { a = 'changed'; return getA(); } make('original'); // 'changed' in most engines — the closure captures the parameter binding ``` That second example is genuinely obscure; the useful takeaway is the first — defaults read the *enclosing* scope, not the body. ## A related syntax rule A parameter list containing any default, rest parameter or destructuring pattern is *non-simple*, and a non-simple parameter list forbids a `'use strict'` directive in the function body: ```js function f(a = 1) { 'use strict'; // SyntaxError } ``` The reason is precisely that parameter initialisers are evaluated in their own scope before the body's directive would take effect. In modules and class bodies, which are already strict, the question never arises. ## How to answer Say "at call time, lazily, left to right". Give the working forward reference (`end = str.length`) and the failing backward one (`a = b, b = 2` → ReferenceError). Add the per-call freshness point, because that is the one with the most practical consequence: mutable defaults are safe in JavaScript in a way people coming from other ecosystems often do not expect.