我的两分钱。。。这是我理解它的方式。（如果我错了，请随时纠正我）

是时候抛弃你所知道的关于传递值/引用的一切了。

因为在JavaScript中，它是通过值传递还是通过引用传递都不重要。重要的是变异与传递给函数的参数赋值。

好吧，让我尽力解释一下我的意思。假设您有几个对象。

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

我们所做的是“任务”。。。我们为变量“object1”和“object2”分配了两个单独的空对象。

现在，假设我们更喜欢对象1。。。因此，我们“分配”一个新变量。

var favoriteObject = object1;

接下来，无论出于什么原因，我们决定更喜欢对象2。所以，我们做了一点重新分配。

favoriteObject = object2;

对象1或对象2未发生任何情况。我们根本没有改变任何数据。我们所做的只是重新分配我们最喜欢的对象。重要的是要知道object2和favoriteObject都分配给了同一个对象。我们可以通过这些变量中的任何一个来改变这个对象。

object2.name = 'Fred';
console.log(favoriteObject.name) // Logs Fred
favoriteObject.name = 'Joe';
console.log(object2.name); // Logs Joe

好了，现在让我们看一下像字符串这样的原语

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

再次，我们选择一个最喜欢的。

var favoriteString = string1;

我们的favoriteString和string1变量都分配给“Helloworld”。现在，如果我们想更改我们的收藏夹字符串？？？会发生什么？？？

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

噢。。。。发生了什么。我们无法通过更改收藏夹字符串来更改字符串1。。。为什么？因为我们没有更改字符串对象。我们所做的只是将favoriteString变量“RE ASSIGN”为一个新字符串。这实际上将其与字符串1断开。在前面的示例中，当我们重命名对象时，我们没有分配任何内容。（好吧，不是变量本身，……但是，我们确实将name属性分配给了一个新字符串。）相反，我们对保持2个变量和基础对象之间连接的对象进行了变异。（即使我们想修改或变异字符串对象本身，我们也不能这样做，因为字符串在JavaScript中实际上是不可变的。）

现在，转到函数和传递参数。。。。当你调用一个函数并传递一个参数时，你所做的基本上是对一个新变量的“赋值”，它的工作方式与你使用等号（=）赋值的方式完全相同。

举这些例子。

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'

现在，同样的事情，但有一个函数

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

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

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

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

好的，现在让我们举几个使用对象的例子。。。首先，没有函数。

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';

现在，同样的事情，但有一个函数调用

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
myFunc(myObject);

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

好的，如果你通读了这篇文章，也许你现在对JavaScript中函数调用的工作方式有了更好的理解。不管什么是通过引用还是通过值传递。。。重要的是赋值与变异。

每次将变量传递给函数时，都会“赋值”参数变量的名称，就像使用等号（=）一样。

始终记住等号（=）表示赋值。始终记住，在JavaScript中向函数传递参数也意味着赋值。它们是相同的，并且这两个变量以完全相同的方式连接（也就是说它们不是，除非你认为它们被分配给了同一个对象）。

“修改变量”影响不同变量的唯一时间是基础对象发生变化时（在这种情况下，您没有修改变量，而是修改对象本身）。

区分对象和基元是没有意义的，因为它的工作方式与没有函数的情况完全相同，只是使用等号分配给一个新变量。

唯一的错误是当传递到函数中的变量的名称与函数参数的名称相同时。当发生这种情况时，您必须将函数内的参数视为该函数专用的一个全新变量（因为它是）

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';

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

对于编程语言律师，我已经阅读了ECMAScript 5.1的以下部分（它比最新版本更容易阅读），并在ECMASript邮件列表中询问了它。

TL；DR：一切都是通过值传递的，但Objects的财产是引用，标准中令人毛骨悚然地缺少Object的定义。

参数列表的构造

第11.2.4节“参数列表”说明了生成仅由1个参数组成的参数列表的以下内容：

生产ArgumentList:AssignmentExpression的计算如下：让ref是赋值表达式的结果。让arg为GetValue（ref）。返回唯一项为arg的列表。

本节还列举了参数列表包含0或>1个参数的情况。

因此，所有的都是通过引用传递的。

对象财产的访问

第11.2.1节“财产访问人”

生产MemberExpression:MemberExpression[Expression]的计算如下：让baseReference作为计算MemberExpression的结果。让baseValue为GetValue（baseReference）。让propertyNameReference作为表达式求值的结果。让propertyNameValue为GetValue（propertyNameReference）。调用CheckObject强制（baseValue）。让propertyNameString为ToString（propertyNameValue）。如果正在计算的语法生成包含在严格模式代码中，则让strict为true，否则让严格是假的。返回一个Reference类型的值，其基值为baseValue，其引用名称为propertyNameString，其严格模式标志为strict。

因此，对象的财产始终可用作参考。

关于参考

第8.7节“引用规范类型”中描述了引用在语言中不是真正的类型——它们仅用于描述删除行为、类型和赋值运算符。

“对象”的定义

5.1版中定义了“对象是财产的集合”。因此，我们可以推断，对象的值是集合，但是关于集合的值是什么，在规范中定义得很差，需要一些努力才能理解。

JavaScript总是按值传递；一切都是价值型的。

对象是值，对象的成员函数本身是值（请记住，函数是JavaScript中的一级对象）。此外，关于JavaScript中的一切都是一个对象的概念；这是错误的。字符串、符号、数字、布尔值、空值和未定义值都是基元。

有时，他们可以利用从基本原型继承的一些成员函数和财产，但这只是为了方便。这并不意味着它们本身就是对象。请尝试以下操作以供参考：

x=“测试”；console.log（x.foo）；x.foo=12；console.log（x.foo）；

在两个console.log中，您都会发现值未定义。

变量不“保存”对象；它有一个参考。您可以将该引用分配给另一个变量，现在两者都引用同一个对象。它总是按值传递（即使该值是引用…）。

无法更改作为参数传递的变量所持有的值，如果JavaScript支持通过引用传递，这是可能的。

观察：如果观察者无法检查引擎的底层内存，则无法确定是否复制了不可变值或传递了引用。

JavaScript或多或少与底层内存模型无关。没有参考²。JavaScript有值。两个变量可以保持相同的值（或者更准确：两个环境记录可以绑定相同的值）。唯一可以变异的值类型是通过抽象[[Get]]和[[Set]]操作的对象。如果您忘记了计算机和内存，这就是描述JavaScript行为所需的全部内容，它可以让您理解规范。

 let a = { prop: 1 };
 let b = a; // a and b hold the same value
 a.prop = "test"; // The object gets mutated, can be observed through both a and b
 b = { prop: 2 }; // b holds now a different value

现在你可能会问自己，两个变量如何在计算机上保持相同的值。然后，您可能会查看JavaScript引擎的源代码，很可能会发现引擎所用语言的程序员会调用引用。

所以事实上，你可以说JavaScript是“值传递”，而值可以被共享，你可以称JavaScript是“引用传递”，这对于低级语言的程序员来说可能是一个有用的逻辑抽象，或者你可以将行为称为“共享调用”。

由于JavaScript中没有引用，所有这些都没有错，也没有切中要害。因此，我不认为搜索答案特别有用。

²规范中的术语“参考”不是传统意义上的参考。它是一个对象和属性名称的容器，并且是一个中间值（例如，a.b计算为Reference｛value=a，name=“b”｝）。术语“引用”有时也出现在规范中的不相关章节中。

如果您想要像其他语言一样的（正常）函数参数行为（传递值的副本）然后在传递到函数之前克隆对象：

function run()
{
    var test = [];
    test.push(1);

    console.log('before: '+test); // 1

    changeVariable(_.clone(test)); // (Note: I am using lodash _.clone() function)
 
    console.log('after: '+test); // 1 
}


function changeVariable(test2) {
  var test1 = test2;
  test1.push(2); 
  console.log('inside func:', test1);  // inside func: [1,2]
}   


run();