On the "pass by value" vs. "pass by reference" controversy, I see two issues here: First, these terms have specific meaning in other languages such as C++, but

On the "pass by value" vs. "pass by reference" controversy, I see two issues here: First, these terms have specific meaning in other languages such as C++, but JavaScript's behavior does not match either of their definitions. Second, there is a widespread myth that JavaScript passes primitive values and objects in two different ways. It doesn't. They work exactly the same, and making an artificial distinction between them is not useful. I find it helpful to make up some new terminology, so my thinking isn't led astray by implied comparisons with other languages. I like to talk about names and things. A name is a variable name or a parameter name. A thing is any object or primitive value: anything that you can pass as a function argument or use on the right side of an assignment operator. A name always refers to one thing. A thing can have multiple names. When you pass an argument into a function, or when you use the assignment operator, you are giving a new name to an existing thing. If the name already referred to some other thing, that connection is lost. The name now refers to the new thing, and only to the new thing. Everything works this way, primitives and objects alike. The reason it's often claimed that objects are passed into a function by reference, while primitives are passed by value, is that we instinctively write different code for the two cases. That different code is what leads to the notion that objects and primitives are treated differently. If you pass an object into a function and you want to add or change a property of that object, you'll naturally write: function foo( obj ) { obj.myprop = 42; } But if you know the function is going to receive a primitive value, you won't write this: function foo( val ) { val.myprop = 42; } If you do, you'll find out soon enough that it won't work. It will throw an exception in strict mode, or fail silently in non-strict mode. Instead you may write: function foo( val ) { // Do stuff here with val val = 42; // Do stuff here with the *new* val, which isn't the old val } The reason the functions behave differently is not because JavaScript passes primitives and objects differently. It doesn't; they are all treated the same. But primitives are immutable. They have no properties that we can change. We know that, or we find out if we try, so we simply don't write code that tries to change a property of a primitive value. It isn't the JavaScript language that treats objects vs. primitives differently when passed into a function or when used in an assignment statement. We programmers do, by writing different code for the two. (Edited for clarity)