3.6 Functions: Pass by Value/Reference

Step 1 — Trace the array argument: weekendTemps is an array, so convertTemps receives a copy of the reference. Both temps and weekendTemps point at the same array in memory. The loop line temps[i] = (temps[i] - 32) * 5 / 9 writes into that shared array element by element:

$$[85, 90, 88] \;\to\; [(85-32)\cdot\tfrac{5}{9},\; (90-32)\cdot\tfrac{5}{9},\; (88-32)\cdot\tfrac{5}{9}]$$

giving [29.444444444444443, 32.22222222222222, 31.11111111111111]. This is mutation — changing the contents of the one and only object.

Step 2 — Trace the string argument: unit is a string, a primitive, so the function received a copy of the value "F". The line unit = "C" is a reassignment: it points only the function's own parameter name at "C", and that parameter disappears when the function ends. The caller's unit still holds "F".

Answer: weekendTemps is [29.444444444444443, 32.22222222222222, 31.11111111111111] and unit is still "F". The array changed because writing to its elements mutates the shared object; the string did not change because reassigning a primitive parameter affects only the copy inside the function.

Step 1 — Apply the rule: Primitives are passed as a copy of the value; objects are passed as a copy of the reference. The seven primitive types are number, string, boolean, null, undefined, symbol, and bigint; everything else — including arrays — is an object.

Step 2 — Classify each item:

• a. a number → primitive → copy of the value
• b. an array → an object → copy of a reference
• c. a string → primitive → copy of the value
• d. an object → copy of a reference
• e. a boolean → primitive → copy of the value

Answer: Copies of the value: a (number), c (string), e (boolean). Copies of a reference: b (array), d (object).

Step 1 — Identify what gets passed: x is a number, a primitive, so update receives a copy of the value 5.

Step 2 — Trace inside the function: val = val + 1 computes \(5 + 1 = 6\) and reassigns the function's own parameter to 6. This changes only the local copy; when the function returns, that copy is discarded.

Step 3 — Check the caller's variable: x was never touched — reassignment of a parameter never reaches back to the caller's variable.

Answer: The output is 5.

Step 1 — Identify what gets passed: scores is an array, so addOne receives a copy of the reference. Both nums and scores point at the same array in memory.

Step 2 — Trace the loop: Each iteration executes nums[i] = nums[i] + 1, which writes into the shared array. This is mutation, not reassignment, so every write is visible outside the function:

$$[10+1,\; 20+1,\; 30+1] = [11,\; 21,\; 31]$$

Step 3 — Check the caller's variable: Since there is only one array, scores now reads [11, 21, 31].

Answer: The output is [11, 21, 31].

Step 1 — Define mutating: Mutating an object means changing its contents while it remains the same object — for example arr.push(4), arr[0] = 7, or person.age = 31. Anyone else holding a reference to that object sees the change, because there is only one object.

Step 2 — Define reassigning: Reassigning a variable means pointing that one name at something entirely different — for example arr = [9, 9] or num = 99. Only that single name moves; everyone else still points where they did before.

Step 3 — Say which one reaches the caller: A function can always mutate an object you passed it, because both names point at the same object. A function can never reassign your variable, because your variable is a separate name holding its own reference or value.

Answer: Mutating changes the contents of the shared object (visible to all holders of a reference); reassigning moves only one name to a new value. A function can mutate in a way the caller notices; it can never reassign the caller's variable.

Step 1 — Examine each line against const: const locks the binding — it prevents reassignment of the name — but it does not prevent mutation of the object the name points at.

Step 2 — Line by line:

• colors.push("blue") mutates the array (adds an element) without changing which array colors points to. This runs fine.
• colors = ["green"] tries to reassign the constant binding to a new array. This throws.

Answer: The line colors = ["green"]; throws TypeError: Assignment to constant variable, because it reassigns a const binding. The earlier push works because const permits mutation of the object's contents.

Step 1 — Define side effect: A side effect is any change a function makes that outlives the call and is visible to the rest of the program — typically mutating an object it was passed.

Step 2 — Example where it is the point: sortScores(scores) calling scores.sort() — reordering the caller's array is exactly what the function exists to do, so the side effect matches the name and the expectation.

Step 3 — Example where it would be a bug: getAverage(nums) that also sorts or empties nums on the way to computing the average. The caller asked for a number but got their data rearranged — an unexpected side effect that damages state they did not agree to change.

Answer: A side effect is a change made by a function that persists after the call and is visible outside it. It is appropriate when it is the function's stated job (e.g., sortScores sorting the array) and a bug when it happens unexpectedly alongside a different promised result (e.g., getAverage also rearranging the input).

Step 1 — Spot the problem: The original loop performs nums[i] = nums[i] * 2, which mutates the caller's array — a side effect the function never advertised.

Step 2 — Rewrite without mutation: Use map, which always builds a new array rather than editing the old one:

function doubleAll(nums) {
  return nums.map(n => n * 2);
}

Step 3 — Verify: Calling doubleAll([1, 2, 3]) returns [2, 4, 6] while the original array stays [1, 2, 3], since no element of the caller's array was ever written to.

Answer:

function doubleAll(nums) {
  return nums.map(n => n * 2);
}

It returns a new doubled array and leaves the caller's array unchanged.