Is JavaScript a pass-by-reference or pass-by-value language? [Answered]


The primitive types (number, string, etc.) are passed by value, but objects are unknown, because they can be both passed-by-value (in case we consider that a variable holding an object is in fact a reference to the object) and passed-by-reference (when we consider that the variable to the object holds the object itself).

Although it doesn’t really matter at the end, I want to know what is the correct way to present the arguments passing conventions. Is there an excerpt from JavaScript specification, which defines what should be the semantics regarding this?

Pass-by-value and pass-by-reference in JavaScript- Answer #1:

It’s interesting in JavaScript. Consider this example:

function changeStuff(a, b, c)
  a = a * 10;
  b.item = "changed";
  c = {item: "changed"};

var num = 10;
var obj1 = {item: "unchanged"};
var obj2 = {item: "unchanged"};

changeStuff(num, obj1, obj2);


This produces the output:

  • If obj1 was not a reference at all, then changing obj1.item would have no effect on the obj1 outside of the function.
  • If the argument was a proper reference, then everything would have changed. num would be 100, and obj2.item would read "changed". Instead, num stays 10 and obj2.item remains "unchanged“.

Instead, the situation is that the item passed in is passed by value. But the item that is passed by value is itself a reference. Technically, this is called call-by-sharing.

In practical terms, this means that if you change the parameter itself (as with num and obj2), that won’t affect the item that was fed into the parameter. But if you change the internals of the parameter, that will propagate back up (as with obj1).

Answer #2:

It’s always pass by value, but for objects the value of the variable is a reference. Because of this, when you pass an object and change its members, those changes persist outside of the function. This makes it look like pass by reference. But if you actually change the value of the object variable you will see that the change does not persist, proving it’s really pass by value.


function changeObject(x) {
  x = { member: "bar" };
  console.log("in changeObject: " + x.member);

function changeMember(x) {
  x.member = "bar";
  console.log("in changeMember: " + x.member);

var x = { member: "foo" };

console.log("before changeObject: " + x.member);
console.log("after changeObject: " + x.member); /* change did not persist */

console.log("before changeMember: " + x.member);
console.log("after changeMember: " + x.member); /* change persists */


before changeObject: foo
in changeObject: bar
after changeObject: foo

before changeMember: foo
in changeMember: bar
after changeMember: bar

Answer #3:

The variable doesn’t “hold” the object; it holds a reference. You can assign that reference to another variable, and now both reference the same object. It’s always pass by value (even when that value is a reference…).

There’s no way to alter the value held by a variable passed as a parameter, which would be possible if JavaScript supported passing by reference.

Answer #4:

My two cents… This is the way I understand it. (Feel free to correct me if I’m wrong)

It’s time to throw out everything you know about pass by value / reference.

Because in JavaScript, it doesn’t matter whether it’s passed by value or by reference or whatever. What matters is mutation vs assignment of the parameters passed into a function.

OK, let me do my best to explain what I mean. Let’s say you have a few objects.

var object1 = {};
var object2 = {};

What we have done is “assignment”… We’ve assigned 2 separate empty objects to the variables “object1” and “object2”.

Now, let’s say that we like object1 better… So, we “assign” a new variable.

var favoriteObject = object1;

Next, for whatever reason, we decide that we like object 2 better. So, we do a little re-assignment.

favoriteObject = object2;

Nothing happened to object1 or to object2. We haven’t changed any data at all. All we did was re-assign what our favorite object is. It is important to know that object2 and favoriteObject are both assigned to the same object. We can change that object via either of those variables. = 'Fred';
console.log( // Logs Fred = 'Joe';
console.log(; // Logs Joe

OK, now let’s look at primitives like strings for example

var string1 = 'Hello world';
var string2 = 'Goodbye world';

Again, we pick a favorite.

var favoriteString = string1;

Both our favoriteString and string1 variables are assigned to ‘Hello world’. Now, what if we want to change our favoriteString??? What will happen???

favoriteString = 'Hello everyone';
console.log(favoriteString); // Logs 'Hello everyone'
console.log(string1); // Logs 'Hello world'

Uh oh…. What has happened. We couldn’t change string1 by changing favoriteString… Why?? Because we didn’t change our string object. All we did was “RE ASSIGN” the favoriteString variable to a new string. This essentially disconnected it from string1. In the previous example, when we renamed our object, we didn’t assign anything. (Well, not to the variable itself, … we did, however, assign the name property to a new string.) Instead, we mutated the object which keeps the connections between the 2 variables and the underlying objects. (Even if we had wanted to modify or mutate the string object itself, we couldn’t have, because strings are actually immutable in JavaScript.)

Now, on to functions and passing parameters…. When you call a function, and pass a parameter, what you are essentially doing is an “assignment” to a new variable, and it works exactly the same as if you assigned using the equal (=) sign.

Take these examples.

var myString = 'hello';

// Assign to a new variable (just like when you pass to a function)
var param1 = myString;
param1 = 'world'; // Re assignment

console.log(myString); // Logs 'hello'
console.log(param1);   // Logs 'world'

Now, the same thing, but with a function

function myFunc(param1) {
    param1 = 'world';

    console.log(param1);   // Logs 'world'

var myString = 'hello';
// Calls myFunc and assigns param1 to myString just like param1 = myString

console.log(myString); // logs 'hello'

OK, now let’s give a few examples using objects instead… first, without the function.

var myObject = {
    firstName: 'Joe',
    lastName: 'Smith'

// Assign to a new variable (just like when you pass to a function)
var otherObj = myObject;

// Let's mutate our object
otherObj.firstName = 'Sue'; // I guess Joe decided to be a girl

console.log(myObject.firstName); // Logs 'Sue'
console.log(otherObj.firstName); // Logs 'Sue'

// Now, let's reassign the variable
otherObj = {
    firstName: 'Jack',
    lastName: 'Frost'

// Now, otherObj and myObject are assigned to 2 very different objects
// And mutating one object has no influence on the other
console.log(myObject.firstName); // Logs 'Sue'
console.log(otherObj.firstName); // Logs 'Jack';

Now, the same thing, but with a function call

function myFunc(otherObj) {

    // Let's mutate our object
    otherObj.firstName = 'Sue';
    console.log(otherObj.firstName); // Logs 'Sue'

    // Now let's re-assign
    otherObj = {
        firstName: 'Jack',
        lastName: 'Frost'
    console.log(otherObj.firstName); // Logs 'Jack'

    // Again, otherObj and myObject are assigned to 2 very different objects
    // And mutating one object doesn't magically mutate the other

var myObject = {
    firstName: 'Joe',
    lastName: 'Smith'

// Calls myFunc and assigns otherObj to myObject just like otherObj = myObject

console.log(myObject.firstName); // Logs 'Sue', just like before

OK, if you read through this entire post, perhaps you now have a better understanding of how function calls work in JavaScript. It doesn’t matter whether something is passed by reference or by value… What matters is assignment vs mutation.

Every time you pass a variable to a function, you are “Assigning” to whatever the name of the parameter variable is, just like if you used the equal (=) sign.

Always remember that the equals sign (=) means assignment. Always remember that passing a parameter to a function in JavaScript also means assignment. They are the same and the 2 variables are connected in exactly the same way (which is to say they aren’t, unless you count that they are assigned to the same object).

The only time that “modifying a variable” affects a different variable is when the underlying object is mutated (in which case you haven’t modified the variable, but the object itself.

There is no point in making a distinction between objects and primitives, because it works the same exact way as if you didn’t have a function and just used the equal sign to assign to a new variable.

The only gotcha is when the name of the variable you pass into the function is the same as the name of the function parameter. When this happens, you have to treat the parameter inside the function as if it was a whole new variable private to the function (because it is)

function myFunc(myString) {
    // myString is private and does not affect the outer variable
    myString = 'hello';

var myString = 'test';
myString = myString; // Does nothing, myString is still 'test';

console.log(myString); // Logs 'test'

Answer #5:

These phrases/concepts were originally defined long before JS was created and they don’t accurately describe the semantics for javascript. I think trying to apply them to JS causes more confusion than not.

So don’t get hung up on “pass by reference/value”.

Consider the following:

  1. Variables are pointers to values.
  2. Reassigning a variable merely points that pointer at a new value.
  3. Reassigning a variable will never affect other variables that were pointing at that same object because each variable has its own pointer.

So if I had to give it a name I’d say “pass-by-pointer” — we don’t deal with pointers in JS but the underlying engine does.

// code
var obj = {
    name: 'Fred',
    num: 1

// illustration
(obj) ---- {}
// code = 'George';

// illustration

(obj) ---- {} ----- 'George'
// code
obj = {};

// illustration

(obj)      {} ----- 'George'
  |          \
  |           \
 { }            1
// code
var obj = {
    text: 'Hello world!'

/* function parameters get their own pointer to 
 * the arguments that are passed in, just like any other variable */

// illustration
(caller scope)        (someFunc scope)
           \             /
            \           /
             \         /
              \       /
               \     /
                 { }
            'Hello world'

Some final comments:

  • The phrases “pass by value/reference” are only used to describe the behavior of a language, not necessarily the actual underlying implementation. As a result of this abstraction, critical details that are essential for a decent explanation are lost, which inevitably leads to the current situation where a single term doesn’t adequately describe the actual behavior without additional info.
  • It’s tempting to think that primitives are enforced by special rules while objects are not, but primitives are simply the end of the pointer chain.
  • As a final example, consider why a common attempt to clear an array doesn’t work as expected.
var a = [1,2];
var b = a;

a = [];
console.log(b); // [1,2]
// doesn't work because `b` is still pointing at the original array

Answer #6:

Think of it like this: It’s always pass by value. However, the value of an object is not the object itself, but a reference to that object.

Here is an example, passing a number (a primitive type)

function changePrimitive(val) {
    // At this point there are two '10's in memory.
    // Changing one won't affect the other
    val = val * 10;
var x = 10;
// x === 10

Repeating this with an object yields different results:

function changeObject(obj) {
    // At this point there are two references (x and obj) in memory,
    // but these both point to the same object.
    // changing the object will change the underlying object that
    // x and obj both hold a reference to.
    obj.val = obj.val * 10;
var x = { val: 10 };
// x === { val: 100 }

One more example:

function changeObject(obj) {
    // Again there are two references (x and obj) in memory,
    // these both point to the same object.
    // now we create a completely new object and assign it.
    // obj's reference now points to the new object.
    // x's reference doesn't change.
    obj = { val: 100 };
var x = { val: 10 };
// x === { val: 10}

Hope you learned something from this post.

Follow Programming Articles for more!

About ᴾᴿᴼᵍʳᵃᵐᵐᵉʳ

Linux and Python enthusiast, in love with open source since 2014, Writer at, India.

View all posts by ᴾᴿᴼᵍʳᵃᵐᵐᵉʳ →