我在AirBNB风格指南中找到了最简洁的解释：

基本体：访问基本体类型时，直接处理其价值一串数字布尔型无效的未定义

例如。：

var foo = 1,
    bar = foo;

bar = 9;

console.log(foo, bar); // => 1, 9

复杂：访问复杂类型时，需要处理对其值的引用对象大堆作用

例如。：

var foo = [1, 2],
    bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

也就是说，基本类型是通过值传递的，复杂类型是通过引用传递的。

在JavaScript中，值的类型仅控制该值是由值副本分配还是由引用副本分配。

基本值始终由值副本分配/传递：

无效的未定义一串数字布尔型ES6中的符号

复合值始终由引用副本分配/传递

物体阵列作用

例如

var a = 2;
var b = a; // `b` is always a copy of the value in `a`
b++;
a; // 2
b; // 3

var c = [1,2,3];
var d = c; // `d` is a reference to the shared `[1,2,3]` value
d.push( 4 );
c; // [1,2,3,4]
d; // [1,2,3,4]

在上面的代码段中，因为2是标量原语，所以a保存该值的一个初始副本，而b被分配了该值的另一个副本。更改b时，绝对不能更改a中的值。

但c和d都是对同一共享值[1，2]的单独引用，这是一个复合值。需要注意的是，c和d都没有“拥有”[1,2,3]值——两者都只是对该值的对等引用。因此，当使用任意一个引用来修改（.push（4））实际的共享数组值本身时，它只影响一个共享值，并且两个引用都将引用新修改的值[1,2,3,4]。

var a = [1,2,3];
var b = a;
a; // [1,2,3]
b; // [1,2,3]

// later
b = [4,5,6];
a; // [1,2,3]
b; // [4,5,6]

当我们赋值b=[4,5,6]时，我们没有做任何事情来影响a仍然引用的位置（[1,2,3]）。要做到这一点，b必须是指向a的指针，而不是对数组的引用——但JS中不存在这样的功能！

function foo(x) {
    x.push( 4 );
    x; // [1,2,3,4]

    // later
    x = [4,5,6];
    x.push( 7 );
    x; // [4,5,6,7]
}

var a = [1,2,3];

foo( a );

a; // [1,2,3,4]  not  [4,5,6,7]

当我们传入参数a时，它将一个引用的副本分配给x。x和a是指向相同[1,2,3]值的独立引用。现在，在函数内部，我们可以使用该引用来改变值本身（push（4））。但是当我们赋值x=[4,5,6]时，这不会影响初始引用a指向的位置——仍然指向（现在已修改）[1,2,3,4]值。

要有效地通过值副本传递复合值（如数组），需要手动复制它，这样传递的引用就不会指向原始值。例如：

foo( a.slice() );

可以通过引用副本传递的复合值（对象、数组等）

function foo(wrapper) {
    wrapper.a = 42;
}

var obj = {
    a: 2
};

foo( obj );

obj.a; // 42

这里，obj充当标量基元属性a的包装器。当传递给foo（..）时，将传入obj引用的副本，并将其设置为wrapper参数。我们现在可以使用包装器引用来访问共享对象，并更新其属性。函数完成后，obj.a将看到更新的值42。

来源

JavaScript很有趣。考虑以下示例：

功能更改Stuff（a、b、c）{a=a*10；b.项目=“已更改”；c＝｛item:“changed”｝；}变量num=10；var obj1=｛item:“未更改”｝；var obj2=｛item:“未更改”｝；changeStuff（num，obj1，obj2）；控制台日志（num）；console.log（obj1.item）；console.log（obj2.item）；

这将产生以下输出：

10
changed
unchanged

如果obj1根本不是引用，则更改obj1.item不会对函数外部的obj1产生影响。如果这个论点是正确的参考，那么一切都会改变。num将为100，obj2.item将为“changed”。相反，num保持10，obj2.item保持“不变”。

相反，情况是传入的项是按值传递的。但通过值传递的项本身就是一个引用。从技术上讲，这叫做共享呼叫。

实际上，这意味着如果更改参数本身（如num和obj2），则不会影响输入到参数中的项。但是，如果更改参数的内部结构，则会向上传播（与obj1一样）。

我发现Undercore.js库的extend方法非常有用，当我想将一个对象作为一个参数传递时，它可以被修改或完全替换。

function replaceOrModify(aObj) {
  if (modify) {

    aObj.setNewValue('foo');

  } else {

   var newObj = new MyObject();
   // _.extend(destination, *sources) 
   _.extend(newObj, aObj);
  }
}

这里有一些关于JavaScript中使用术语“通过引用传递”的讨论，但要回答您的问题：

对象通过引用自动传递，无需特别声明

（摘自上述文章。）

这是对值传递和引用传递（JavaScript）的更多解释。在这个概念中，他们讨论的是通过引用传递变量和通过引用传递该变量。

传递值（基本类型）

var a = 3;
var b = a;

console.log(a); // a = 3
console.log(b); // b = 3

a=4;
console.log(a); // a = 4
console.log(b); // b = 3

应用于JavaScript中的所有基元类型（字符串、数字、布尔值、未定义和null）。a被分配一个存储器（例如0x001），b在存储器中创建该值的拷贝（例如0x002）。因此，更改一个变量的值不会影响另一个变量，因为它们都位于两个不同的位置。

通过引用（对象）

var c = { "name" : "john" };
var d = c;

console.log(c); // { "name" : "john" }
console.log(d); // { "name" : "john" }

c.name = "doe";

console.log(c); // { "name" : "doe" }
console.log(d); // { "name" : "doe" }

JavaScript引擎将对象分配给变量c，并指向某个内存，例如（0x012）。当d=c时，在该步骤中，d指向相同的位置（0x012）。更改任何变量的值都会更改这两个变量的值。函数是对象

特殊情况，通过引用传递（对象）

c = {"name" : "jane"};
console.log(c); // { "name" : "jane" }
console.log(d); // { "name" : "doe" }

等号（=）运算符设置新的内存空间或地址