Pass by value and reference in JavaScript

This chapter follows Data types in JavaScript.

Consider let x = []. Strictly speaking, x does not contain an array literal sitting inside the variable. It holds a reference to a heap object whose contents are an empty array. Consider let x = 5. Here x holds the number 5 itself. No indirection is involved for that primitive.

The split matches the type system: the seven primitives copy by value; Object (and every value that typeof reports as object or function) shares identity through references.

Primitives copy by value

When you assign one primitive to another binding, the engine copies the bits of the value. Changing the copy does not change the original.

1
let x = 1;
2
let y = x;
3
y = 2;
4

5
console.log(x === 1); // true
6
console.log(y === 2); // true

The same rule applies to bigint, string, boolean, symbol, null, and undefined. Strings look like they might share structure internally because of engine optimizations, but the language model treats each assignment as an independent primitive value.

Objects share one identity

Assigning an object copies the reference, not a deep clone of every property. Two bindings can point at the same object; mutating through either binding is visible on both.

1
const obj = {
2
  innerObj: {
3
    x: 9,
4
  },
5
};
6

7
const z = obj.innerObj;
8
z.x = 25;
9
console.log(obj.innerObj.x); // 25

z and obj.innerObj refer to the same object. Updating z.x updates that object’s property.

Reassigning a reference

Reassignment replaces which object a binding points to. It does not mutate the object you pointed at before unless you mutated it earlier.

1
const obj = {
2
  arr: [{ x: 17 }],
3
};
4

5
let z = obj.arr;
6
z = [{ x: 25 }];
7

8
console.log(obj.arr[0].x); // 17

z = [{ x: 25 }] makes z reference a new array. obj.arr still references the original array. The old reference stored in z becomes unreachable if nothing else uses it and is eventually collected.

Mutating through a shared reference

Methods that change an object in place (push, property assignment, and so on) run on the shared identity:

1
const obj = {
2
  arr: [],
3
};
4

5
obj.arr.push(17);
6

7
console.log(obj.arr === [17]); // false — different array objects
8
console.log(obj.arr[0] === 17); // true — same contents, not the same reference as [17]

obj.arr holds the array that was mutated. A fresh [17] literal is a different object, so strict equality between references is false even when the elements match.

Arguments and function calls

JavaScript is pass by value at the language level: the callee receives a copy of whatever was in the argument slot. For objects, that copy is the reference value, so the callee can mutate the same object the caller sees. For primitives, the callee gets an independent copy; reassigning the parameter does not reassign the caller’s variable.

1
function bump(n, bag) {
2
  n += 1;
3
  bag.count += 1;
4
}
5

6
let total = 0;
7
const holder = { count: 0 };
8
bump(total, holder);
9

10
console.log(total);       // 0 — number was copied
11
console.log(holder.count); // 1 — object identity was shared

const and references

const prevents rebinding the variable. It does not freeze object contents.

1
const row = { id: 1 };
2
row.id = 2;        // allowed — mutating the object
3
// row = {};       // SyntaxError — rebinding forbidden

When you need a snapshot of nested data, copy explicitly (structuredClone, spread, or a library), especially before passing data across async boundaries or into reducers that assume immutability.

Next: Type coercion and equality.