原语通过值传递，对象通过“引用的副本”传递。

具体来说，当您传递一个对象（或数组）时，您（不可见地）传递了对该对象的引用，并且可以修改该对象的内容，但是如果您尝试覆盖该引用，则不会影响该对象的副本调用者持有的引用 - 即引用本身是按值传递的：

function replace(ref) {
    ref = {};           // this code does _not_ affect the object passed
}

function update(ref) {
    ref.key = 'newvalue';  // this code _does_ affect the _contents_ of the object
}

var a = { key: 'value' };
replace(a);  // a still has its original value - it's unmodfied
update(a);   // the _contents_ of 'a' are changed

可以这样想：

每当你在 ECMAscript 中创建一个对象时，这个对象就会在一个神秘的ECMAscript 通用位置形成，在那里任何人都无法获得。你得到的只是对这个神秘地方的那个对象的引用。

var obj = { };

Evenobj只是对对象（位于那个特别美妙的地方）的引用，因此，您只能传递这个引用。实际上，任何访问obj的代码都会修改很远很远的对象。

我的两分钱.... JavaScript 是按引用还是按值传递参数无关紧要。真正重要的是赋值与变异。

我在这个链接中写了更长、更详细的解释。

当你传递任何东西（无论是对象还是基元）时，JavaScript 所做的就是在函数内部分配一个新变量……就像使用等号 ( =) 一样。

该参数在函数内的行为方式与仅使用等号分配新变量时的行为方式完全相同……以这些简单的示例为例。

var myString = 'Test string 1';

// Assignment - A link to the same place as myString
var sameString = myString;

// If I change sameString, it will not modify myString,
// it just re-assigns it to a whole new string
sameString = 'New string';

console.log(myString); // Logs 'Test string 1';
console.log(sameString); // Logs 'New string';

如果我要myString作为参数传递给函数，它的行为就像我只是将它分配给一个新变量一样。现在，让我们做同样的事情，但是用一个函数而不是一个简单的赋值

function myFunc(sameString) {

  // Reassignment... Again, it will not modify myString
  sameString = 'New string';
}

var myString = 'Test string 1';

// This behaves the same as if we said sameString = myString
myFunc(myString);

console.log(myString); // Again, logs 'Test string 1';

当您将对象传递给函数时，您可以修改对象的唯一原因是因为您没有重新分配……相反，对象可以更改或变异……同样，它的工作方式相同。

var myObject = { name: 'Joe'; }

// Assignment - We simply link to the same object
var sameObject = myObject;

// This time, we can mutate it. So a change to myObject affects sameObject and visa versa
myObject.name = 'Jack';
console.log(sameObject.name); // Logs 'Jack'

sameObject.name = 'Jill';
console.log(myObject.name); // Logs 'Jill'

// If we re-assign it, the link is lost
sameObject = { name: 'Howard' };
console.log(myObject.name); // Logs 'Jill'

如果我要myObject作为参数传递给函数，它的行为就像我只是将它分配给一个新变量一样。同样，具有完全相同行为但具有功能的相同事物。

function myFunc(sameObject) {
  // We mutate the object, so the myObject gets the change too... just like before.
  sameObject.name = 'Jill';

  // But, if we re-assign it, the link is lost
  sameObject = {
    name: 'Howard'
  };
}

var myObject = {
  name: 'Joe'
};

// This behaves the same as if we said sameObject = myObject;
myFunc(myObject);
console.log(myObject.name); // Logs 'Jill'

每次将变量传递给函数时，您都在“分配”参数的名称，就像使用=等号一样。

永远记住等号=意味着赋值。将参数传递给函数也意味着赋值。它们是相同的，并且两个变量以完全相同的方式连接。

修改变量影响不同变量的唯一时间是底层对象发生变异时。

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

函数参数通过值或共享传递，但在 JavaScript 中永远不会通过引用！

value调用

原始类型按值传递：

var num = 123, str = "foo";

function f(num, str) {
  num += 1;
  str += "bar";
  console.log("inside of f:", num, str);
}

f(num, str);
console.log("outside of f:", num, str);

函数作用域内的重新分配在周围作用域中不可见。

这也适用于Strings，它是一种复合数据类型，但不可变：

var str = "foo";

function f(str) {
  str[0] = "b"; // doesn't work, because strings are immutable
  console.log("inside of f:", str);
}

f(str);
console.log("outside of f:", str);

呼叫共享

对象，即所有不是基元的类型，都是共享传递的。保存对象引用的变量实际上仅保存该引用的副本。如果 JavaScript 将采用按引用调用的评估策略，则该变量将保存原始引用。这是 by-sharing 和 by-reference 之间的关键区别。

这种区别的实际后果是什么？

var o = {x: "foo"}, p = {y: 123};

function f(o, p) {
  o.x = "bar"; // Mutation
  p = {x: 456}; // Reassignment
  console.log("o inside of f:", o);
  console.log("p inside of f:", p);
}

f(o, p);

console.log("o outside of f:", o);
console.log("p outside of f:", p);

变异意味着修改现有Object. 变量绑定到的引用副本和引用此对象的引用副本保持不变。因此，突变在调用者的范围内是可见的。

重新分配意味着替换绑定到变量的引用副本。由于它只是一个副本，因此持有相同引用副本的其他变量不受影响。因此，重新分配在调用者的范围内是不可见的，就像它们在调用引用评估策略中一样。

有关ECMAScript 中评估策略的更多信息。

与 C 一样，归根结底，一切都是按值传递的。与 C 不同，您实际上无法备份和传递变量的位置，因为它没有指针，只有引用。

它所拥有的引用都是对象，而不是变量。有几种方法可以实现相同的结果，但它们必须手动完成，而不仅仅是在调用或声明站点添加关键字。