一切都是通过价值传递的。

基本类型按值传递（即，实际变量值的新副本传递给函数）。

复杂类型（对象）作为“对象指针”传递。因此，您传递的实际内容是一个指针，它是按值传递的（它是一个地址，一个像任何其他值一样的数值）。显然，如果您试图在函数内修改对象的属性，那么即使在该函数外，修改也会反映出来。这是因为您通过指向属性唯一副本的指针访问属性。

这里的混淆出现在“通过值传递指针”和“通过引用传递对象”上。

我在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

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

确定某个对象是否“通过引用传递”的一个简单方法是您是否可以编写“交换”函数。例如，在C中，您可以执行以下操作：

void swap(int *i, int *j)
{
    int t;
    t = *i;
    *i = *j;
    *j = t;
}

如果你不能在JavaScript中做到这一点，那就不是“通过引用传递”。

在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。

来源

函数内部的简单值不会改变函数外部的值（通过值传递），而复杂值会（通过引用传递）。

function willNotChange(x) {

    x = 1;
}

var x = 1000;

willNotChange(x);

document.write('After function call, x = ' + x + '<br>'); // Still 1000

function willChange(y) {

    y.num = 2;
}

var y = {num: 2000};

willChange(y);
document.write('After function call y.num = ' + y.num + '<br>'); // Now 2, not 2000

这些短语/概念最初是在JS创建之前很久定义的，它们没有准确描述javascript的语义。我认为尝试将它们应用于JS会导致更多的困惑。

所以不要被“通过引用/值传递”挂断。

考虑以下事项：

变量是指向值的指针。重新分配变量只会将指针指向新值。重新分配变量不会影响指向同一对象的其他变量，因为每个变量都有自己的指针。

所以如果我必须给它起个名字，我会说“passbypointer”——我们不处理JS中的指针，但底层引擎会处理。

// code
var obj = {
    name: 'Fred',
    num: 1
};

// illustration
               'Fred'
              /
             /
(obj) ---- {}
             \
              \
               1

// code
obj.name = 'George';


// illustration
                 'Fred'


(obj) ---- {} ----- 'George'
             \
              \
               1

// code
obj = {};

// illustration
                 'Fred'


(obj)      {} ----- 'George'
  |          \
  |           \
 { }            1

// code
var obj = {
    text: 'Hello world!'
};

/* function parameters get their own pointer to 
 * the arguments that are passed in, just like any other variable */
someFunc(obj);


// illustration
(caller scope)        (someFunc scope)
           \             /
            \           /
             \         /
              \       /
               \     /
                 { }
                  |
                  |
                  |
            'Hello world'

一些最终意见：

短语“传递值/引用”仅用于描述语言的行为，不一定是实际的底层实现。由于这种抽象，对于正确解释至关重要的关键细节丢失了，这不可避免地导致了当前的情况，在没有额外信息的情况下，单个术语无法充分描述实际行为。人们很容易认为原语是由特殊规则强制执行的，而对象不是，但原语只是指针链的末端。作为最后一个示例，请考虑为什么清除数组的常见尝试不能按预期工作。

变量a=[1，2]；变量b=a；a=[]；console.log（b）；//[1,2]//不起作用，因为“b”仍指向原始数组