?
Javascript的所有函数传参都是靠值参数，而包括对象的传参，也是靠值传参，而不是
靠引用来传参。其实java方法的参数所有的也都是靠值参数的。passed by value，没
有靠引用传参。这一点很多人可能有误解的。
?
下面摘自（Professional.JavaScript.for.Web.Developers.2nd.Edition.pdf【javascrip高级程序设计】）
Argument Passing
All function arguments in ECMAScript are passed by value. This means that the value outside of the
function is copied into an argument on the inside of the function the same way a value is copied from
one variable to another. If the value is primitive, then it acts just like a primitive variable copy, but if the
value is a reference, it acts just like a reference variable copy. This is often a point of confusion for
developers because variables are accessed both by value and by reference, but arguments are passed
only by value.
When an argument is passed by value, the value is copied into a local variable (a named argument or, in
ECMAScript, a slot in the arguments object). When an argument is passed by reference, the location of
the value in memory is stored into a local variable, which means that changes to the local variable are
reflected outside of the function. Consider the following example:
function addTen(num) {
num += 10;
return num;
}
var count = 20;
var result = addTen(count);
alert(count); //20 - no change
alert(result); //30
?
Chapter 4: Variables, Scope, and Memory?83
Here, the function addTen() has an argument num , which is essentially a local variable. When called,
the variable count is passed in as an argument. This variable has a value of 20, which is copied into the
argument num for use inside of addTen() . Within the function, the argument num has its value changed
by adding 10, but this doesn ’ t change the original variable count that exists outside of the function. The
argument num and the variable count do not recognize each other; they only happen to have the same
value. If num had been passed by reference, then the value of count would have changed to 30 to reflect
the change made inside the function. This fact is obvious when using primitive values such as numbers,
but things aren ’ t as clear when using objects. Take this for example:
function setName(obj) {
obj.name = “Nicholas”;
}
var person = new Object();
setName(person);
alert(person.name); //”Nicholas”
?
In this code, an object is created and stored in the variable person . This object is then passed into the
setName() method, where it is copied into obj . Inside the function, obj and person both point to
the same object. The result is that obj is accessing an object by reference, even though it was passed into
the function by value. When the name property is set on obj inside the function, this change is reflected
outside the function because the object that it points to exists globally on the heap. Many developers
incorrectly assume that when a local change to an object is reflected globally, that means an argument
was passed by reference. To prove that objects are passed by value, consider the following modified code:
function setName(obj) {
obj.name = “Nicholas”;
obj = new Object();
obj.name = “Greg”;
}
var person = new Object();
setName(person);
alert(person.name); //”Nicholas”
?
The only change between this example and the previous one are two lines added to setName() that
redefine object as a new object with a different name. When person is passed into setName() , its name
property is set to ” Nicholas ” . Then the variable obj is set to be a new object and its name property is
set to ” Greg ” . If person were passed by reference, then person would automatically be changed to
point to the object whose name is ” Greg ” . However, when person.name is accessed again, its value is
” Nicholas ” , indicating that the original reference remained intact even though the argument ’ s value
changed inside the function. When obj is overwritten inside the function, it becomes a pointer to a local
object. That local object is destroyed as soon as the function finishes executing.
Think of function arguments in ECMAScript as