Frontend interview answer

Predict Object Mutation Across Function Arguments

HighIntermediateJavascript

By FrontendAtlas Editorial · Updated Jul 17, 2026

Output challenge

The interactive answer choices load in your browser.

Interview focus

This JavaScript interview question tests whether you can explain JavaScript argument passing output: object mutation vs reassignment, connect it to production trade-offs, and handle common follow-up questions.

JavaScript argument passing output: object mutation vs reassignment explanation without falling back to memorized definitions
Pass By Value and Pass By Reference reasoning, edge cases, and production failure modes
How you would answer the most likely JavaScript interview follow-up

Practice more JavaScript interview questions

Interview answer drill

Use this JavaScript interview question to rehearse a quick answer, common mistake, follow-up, and production pitfall.

Practice more JavaScript interview questions Follow JavaScript mastery study plan Open Essential 60

Deep dive

Trace the two values separately

The output is 1, then 2. JavaScript passes every argument by value, but the kind of value matters. When score is passed, the parameter receives the primitive number 1. The statement score += 1 changes only that local parameter to 2; it cannot rewrite the outer variable.

For state, the value being copied identifies an object. The outer variable and the parameter therefore identify the same object at first. state.count += 1 changes that shared object's property from 1 to 2, so the caller observes the mutation. The later assignment state = { count: 99 } points only the local parameter at a new object. It neither replaces the caller's binding nor undoes the earlier mutation. After the function returns, the local binding disappears, the original object still has count: 2, and the outer score is still 1.

Operation	What changes	Visible to caller?
score += 1	The local parameter receives a different primitive value.	No — outer score stays 1.
state.count += 1	A property on the object identified by both bindings is mutated.	Yes — outer state.count becomes 2.
state = { count: 99 }	The local parameter is reassigned to identify a new object.	No — outer state still identifies the first object.

Object mutation and parameter reassignment affect different things, even though both statements use the state parameter.

JAVASCRIPT

function updateWithoutMutation(score, state) {
  return {
    score: score + 1,
    state: { ...state, count: state.count + 1 }
  };
}

const result = updateWithoutMutation(score, state);

console.log(result.score);       // 2
console.log(result.state.count); // 2
console.log(score);              // 1
console.log(state.count);        // 1

Prefer an explicit result when mutation is surprising

The non-mutating version returns both updated values and creates a new state object with object spread. Its caller can deliberately adopt the result, while the original score and state remain unchanged. This makes data flow easier to review in reducers, state stores, and component inputs.

Calling JavaScript "pass by reference" is misleading because reassigning state inside the function would then be expected to replace the caller's variable. A more precise mental model is: arguments are passed by value, and an object value lets multiple bindings reach the same mutable object. Ask whether a line changes a binding or mutates the object it identifies; that distinction predicts the result without memorizing special cases.