我会说这是通过复印件传递的-

考虑参数和变量对象是在函数调用开始时创建的执行上下文中创建的对象，传递到函数中的实际值/引用只存储在这个参数+变量对象中。

简单地说，对于基元类型，值在函数调用开始时被复制，对于对象类型，引用被复制。

在低级语言中，如果要通过引用传递变量，则必须在创建函数时使用特定语法：

int myAge = 14;
increaseAgeByRef(myAge);
function increaseAgeByRef(int &age) {
  *age = *age + 1;
}

&age是对myAge的引用，但如果您需要该值，则必须使用*age转换引用。

JavaScript是一种高级语言，可以为您进行这种转换。

因此，尽管对象是通过引用传递的，但语言将引用参数转换为值。您不需要在函数定义上使用&来通过引用传递它，也不需要在功能体上使用*来将引用转换为值，JavaScript会为您执行此操作。

这就是为什么当您试图通过替换函数中的对象的值（即age={value:5}）来更改该对象时，更改不会持久，但如果您更改了它的财产（即age.value=5），更改就会持久。

了解更多信息

它总是按值传递，但对于对象，变量的值是一个引用。因此，当您传递一个对象并更改其成员时，这些更改将在函数之外持续存在。这使得它看起来像是通过引用传递。但如果您实际更改了对象变量的值，您将看到更改不会持续，这证明它确实是通过值传递的。

例子：

函数changeObject（x）{x={member:“bar”}；console.log（“in changeObject:”+x.member）；}函数changeMember（x）{x.member=“bar”；console.log（“in changeMember:”+x.member）；}var x＝｛member:“foo”｝；console.log（“before changeObject:”+x.member）；changeObject（x）；console.log（“after changeObject:”+x.member）；/*更改没有持续*/console.log（“changeMember之前：”+x.member）；changeMember（x）；console.log（“after changeMember:”+x.member）；/*更改持续存在*/

输出：

before changeObject: foo
in changeObject: bar
after changeObject: foo

before changeMember: foo
in changeMember: bar
after changeMember: bar

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

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

这样想：它总是通过价值传递。然而，对象的值不是对象本身，而是对该对象的引用。

下面是一个例子，传递一个数字（一个原始类型）

function changePrimitive(val) {
    // At this point there are two '10's in memory.
    // Changing one won't affect the other
    val = val * 10;
}
var x = 10;
changePrimitive(x);
// x === 10

对对象重复此操作会产生不同的结果：

function changeObject(obj) {
    // At this point there are two references (x and obj) in memory,
    // but these both point to the same object.
    // changing the object will change the underlying object that
    // x and obj both hold a reference to.
    obj.val = obj.val * 10;
}
var x = { val: 10 };
changeObject(x);
// x === { val: 100 }

再举一个例子：

function changeObject(obj) {
    // Again there are two references (x and obj) in memory,
    // these both point to the same object.
    // now we create a completely new object and assign it.
    // obj's reference now points to the new object.
    // x's reference doesn't change.
    obj = { val: 100 };
}
var x = { val: 10 };
changeObject(x);
// x === { val: 10}

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

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”｝）。术语“引用”有时也出现在规范中的不相关章节中。